00:00:04 -!- littlebo1eep has quit (Ping timeout: 240 seconds).
00:03:04 -!- littlebo1eep has joined.
00:03:04 -!- littlebobeep has quit (Ping timeout: 240 seconds).
00:19:43 <zzo38> Some instructions of RISC-V bit manipulation extension seems to be similar to MMIX but seems many don't, and RISC-V does not seems to have the MOR and MXOR instructions of MMIX, even though I think that it would be good. However, RISC-V is 32-bits and 64-bits, and MMIX is only 64-bits, so maybe that is why they did not put them in RISC-V?
00:24:53 <esolangs> [[Path]] https://esolangs.org/w/index.php?diff=97716&oldid=97706 * Masalt * (+78) /* Instructions */
00:33:29 -!- monoxane4 has joined.
00:34:30 -!- monoxane has quit (Ping timeout: 276 seconds).
00:34:30 -!- monoxane4 has changed nick to monoxane.
00:46:37 <esolangs> [[Special:Log/newusers]] create * Xarthan * New user account
00:46:38 -!- Lord_of_Life has quit (Ping timeout: 258 seconds).
00:47:24 -!- Lord_of_Life has joined.
00:49:12 -!- monoxane9 has joined.
00:51:02 -!- monoxane has quit (Ping timeout: 255 seconds).
00:51:02 -!- monoxane9 has changed nick to monoxane.
01:01:29 <esolangs> [[Esolang:Introduce yourself]] M https://esolangs.org/w/index.php?diff=97717&oldid=97688 * Xarthan * (+270)
01:06:11 -!- monoxane8 has joined.
01:07:19 -!- monoxane has quit (Ping timeout: 258 seconds).
01:07:20 -!- monoxane8 has changed nick to monoxane.
01:15:56 <esolangs> [[Brain Ah Fuck]] N https://esolangs.org/w/index.php?oldid=97718 * Xarthan * (+155) categories i need to go to bed
01:16:37 <esolangs> [[Brain Ah Fuck]] M https://esolangs.org/w/index.php?diff=97719&oldid=97718 * Xarthan * (+21) i need to go to bed
01:46:31 -!- Sgeo has quit (Read error: Connection reset by peer).
01:48:32 -!- Sgeo has joined.
01:58:22 -!- monoxane1 has joined.
01:59:57 -!- monoxane has quit (Ping timeout: 256 seconds).
01:59:57 -!- monoxane1 has changed nick to monoxane.
02:07:52 -!- monoxane1 has joined.
02:08:30 -!- monoxane has quit (Ping timeout: 246 seconds).
02:08:30 -!- monoxane1 has changed nick to monoxane.
02:13:51 -!- monoxane2 has joined.
02:15:49 -!- monoxane has quit (Ping timeout: 256 seconds).
02:15:49 -!- monoxane2 has changed nick to monoxane.
02:23:04 -!- monoxane5 has joined.
02:23:54 -!- monoxane has quit (Ping timeout: 246 seconds).
02:23:54 -!- monoxane5 has changed nick to monoxane.
02:28:37 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97720&oldid=97699 * Z Ling * (+5)
02:29:07 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97721&oldid=97720 * Z Ling * (-2)
02:29:24 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97722&oldid=97721 * Z Ling * (-5) /* */
02:30:40 -!- monoxane1 has joined.
02:31:50 -!- monoxane has quit (Ping timeout: 255 seconds).
02:31:50 -!- monoxane1 has changed nick to monoxane.
02:37:17 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97723&oldid=97722 * Z Ling * (+281)
02:57:34 -!- littlebo1eep has quit (Ping timeout: 240 seconds).
03:09:30 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97724&oldid=97723 * Z Ling * (-43) /* */
03:12:11 -!- monoxane8 has joined.
03:13:50 -!- monoxane has quit (Ping timeout: 240 seconds).
03:13:50 -!- monoxane8 has changed nick to monoxane.
03:15:03 <HackEso> The password of the month is not a password, but a special phrase-guessing operation.
03:24:12 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97725&oldid=97724 * Z Ling * (+721) /* */
03:24:53 <HackEso> 12452:2022-05-11 <Corbïn> learn The password of the month is not a password, but a special phrase-guessing operation. \ 12450:2022-03-01 <int-̈e> learn The password of the month is marching on. \ 12448:2022-02-02 <oerjän> learn The password of the month is decided with a non-terminating computation. \ 12445:2022-01-01 <int-̈e> learn The password of the month is Caught-22 \ 12444:2022-01-01 <int-̈e> learn The password of the month is Catch-22 \ 12432
03:25:12 <shachaf> There was no password of April?
03:25:41 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97726&oldid=97725 * Z Ling * (-135) /* */
03:28:30 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97727&oldid=97726 * Z Ling * (+557) /* */
03:31:12 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97728&oldid=97727 * Z Ling * (-491) /* */
03:31:36 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97729&oldid=97728 * Z Ling * (-8) /* */
03:40:29 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97730&oldid=97729 * Z Ling * (+345)
03:50:03 <esolangs> [[User:Masalt]] https://esolangs.org/w/index.php?diff=97731&oldid=97520 * Masalt * (-2) /* Coming Soon */
03:50:14 -!- littlebobeep has joined.
03:50:43 <esolangs> [[User:Masalt]] https://esolangs.org/w/index.php?diff=97732&oldid=97731 * Masalt * (+3) /* Coming Soon */
03:54:07 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=97733 * Masalt * (+98) Created page with "{{stub}}{{WIP}} is an [[esoteric programming language]] made by [[User:Masalt]] in Python 3."
03:54:45 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97734&oldid=97730 * Z Ling * (+477)
03:55:57 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97735&oldid=97734 * Z Ling * (+6) /* */
03:57:24 -!- monoxane6 has joined.
03:58:23 -!- monoxane has quit (Ping timeout: 256 seconds).
03:58:24 -!- monoxane6 has changed nick to monoxane.
04:02:32 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97736&oldid=97735 * Z Ling * (-362)
04:03:31 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97737&oldid=97736 * Z Ling * (+55)
04:11:14 -!- monoxane7 has joined.
04:13:14 -!- monoxane has quit (Ping timeout: 258 seconds).
04:13:15 -!- monoxane7 has changed nick to monoxane.
04:13:28 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97738&oldid=97737 * Z Ling * (+183)
04:15:06 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97739&oldid=97738 * Z Ling * (+61) /* */
04:17:33 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97740&oldid=97739 * Z Ling * (+85)
04:19:47 -!- monoxane2 has joined.
04:20:07 -!- monoxane has quit (Ping timeout: 240 seconds).
04:20:07 -!- monoxane2 has changed nick to monoxane.
04:28:37 -!- monoxane2 has joined.
04:31:06 -!- monoxane has quit (Ping timeout: 276 seconds).
04:31:06 -!- monoxane2 has changed nick to monoxane.
04:40:40 -!- monoxane9 has joined.
04:42:35 -!- monoxane has quit (Ping timeout: 256 seconds).
04:42:36 -!- monoxane9 has changed nick to monoxane.
05:06:10 -!- monoxane5 has joined.
05:07:21 -!- monoxane has quit (Ping timeout: 246 seconds).
05:07:21 -!- monoxane5 has changed nick to monoxane.
05:13:20 -!- monoxane9 has joined.
05:14:11 -!- monoxane has quit (Ping timeout: 258 seconds).
05:14:12 -!- monoxane9 has changed nick to monoxane.
05:46:41 -!- monoxane has quit (Ping timeout: 255 seconds).
05:47:38 -!- monoxane has joined.
05:49:46 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97741&oldid=97740 * Z Ling * (-59) /* */
05:51:30 -!- monoxane0 has joined.
05:52:13 <esolangs> [[Gino]] https://esolangs.org/w/index.php?diff=97742&oldid=97741 * Z Ling * (-14)
05:53:26 -!- monoxane has quit (Ping timeout: 255 seconds).
05:54:01 <esolangs> [[User talk:Z Ling]] N https://esolangs.org/w/index.php?oldid=97743 * Z Ling * (+0) Created blank page
05:55:25 -!- monoxane has joined.
05:56:44 -!- monoxane0 has quit (Ping timeout: 258 seconds).
06:04:34 -!- littlebobeep has quit (Ping timeout: 240 seconds).
06:34:13 -!- Sgeo has quit (Read error: Connection reset by peer).
06:35:41 -!- monoxane6 has joined.
06:37:18 -!- monoxane has quit (Ping timeout: 246 seconds).
06:37:19 -!- monoxane6 has changed nick to monoxane.
06:42:05 -!- definitelya has joined.
06:54:12 <river> lets talk about complexity
06:54:17 <river> exists L, K(x) > L
06:54:32 <river> exists L, ~Prf[K(x) > L]
06:54:55 <river> exists L, forall x, ~Prf[K(,x) > L]
06:55:00 <river> I guess this is the correct statement
06:55:11 <river> we want to prove it by contradiction
06:55:25 <river> so assume that for all L, exists x, Prf[K(,x) > L]
06:56:54 <river> why is this contradictory?
06:58:01 <river> we have to make a computer program that loops through all proofs in size order
06:59:08 <river> so this program will get us an x and a proof of K(x) > L
06:59:44 <river> the size of this program is O(1) + log(L)
07:00:49 <river> therefor K(x) = O(1) + log(L) which will be < L at some point
07:00:52 <river> that is a contradiction
07:07:43 <river> wait there is an error here?
07:07:55 <river> we fixed x and increased L
07:08:01 <river> but the order of quantifiers does not allow that?
07:12:13 <shachaf> I think you want L to be the size of your program.
07:14:12 <river> L is supposed to be a number
07:14:49 <shachaf> Yes. Make it be the size of the program (which also includes L, which takes log L bits).
07:15:21 <river> the program isn't "closed", it takes an input x
07:15:37 <shachaf> I thought it searches for x.
07:15:41 <river> oh yes you're right
07:16:01 <river> it outputs a pair, (x : Nat, prf : Prf[K(,x) > L])
07:16:36 <river> so we can actually calculate such an L for real
07:16:50 <river> (smaller L may exist)
07:16:52 <river> the PDF suggested that L was completely unknown
07:17:11 <shachaf> No, you can upper-bound it with the size of such a program.
07:18:26 <shachaf> I should never say "upper-bound" or "lower-bound" when I can just say "bound" and people will assume I know which one I meant.
07:18:34 <shachaf> It's just a coin flip, especially past midnight.
07:18:55 <river> now there is an interesting point next
07:19:13 <river> we cannot prove any K(x) > L
07:19:27 <river> but there is a reasonable argument that K(x) > L is actually true for some x's
07:19:46 <shachaf> Of course, it's true for almost all xs.
07:20:04 <river> which is interesting, because i remember people making a big fuss about how the godel sentence was true - and i was always extremely suspicious of that
07:20:27 <river> it seemed a bit abstract, and the reasoning a bit vague
07:21:00 <shachaf> Hmm, how do you feel about the following: "river can't agree with this sentence"
07:22:54 <river> actually I don't understand why K(x) > L is true
07:23:05 <river> its something to do with 2^L
07:24:19 <shachaf> Right, it's the pigeonhole argument about compression.
07:25:17 <river> K(x) can be read as 'the best we can compress x'
07:26:10 <shachaf> There are only about 2^L programs shorter than L. Each one of them emits one string if it halts. That's a finite set of strings.
07:26:27 <river> there's exponentially many strings, and compression can be arbitrarily good.. but the problem is there's only so many "short" strings for someone to be compressed into
07:26:31 <shachaf> So all the other strings out there require bigger programs (since certainly every string has a program that prints it).
07:26:41 <river> ahh nice explanation
07:27:11 <river> that shows us that for every L, there does exist an x such that K(x) > L
07:27:19 <river> but we proved that we cannot prove this for large enough L
07:27:26 <river> this seems like a contradiction?
07:27:36 <river> we proved that we can't prove something.. then we proved it
07:27:37 <shachaf> We can't prove it for any specific string.
07:28:03 <river> is that at all similar to omega consistency?
07:28:21 <shachaf> If you see a big random-looking string, bigger than L, you might say "you can't do much better than just print(s) to generate this string, it's basically incompressible".
07:28:29 <shachaf> But then maybe you can find out that it was actually generated by a small program.
07:28:55 <river> if the string is really big it's literally *impossible* to prove that it was generate by a short program
07:29:03 <river> that's really surprising
07:29:22 <river> short program is wrong
07:29:33 <river> let's call a program with size > L , a big program
07:29:34 <shachaf> Impossible to prove that it wasn't.
07:29:48 <river> if the string is really big it's literally *impossible* to prove that it needs to be generated by a big program
07:29:59 <river> that's less shocking, but still surprising
07:30:20 <shachaf> If you have a small program that generates it, the proof is just "run this program for k steps".
07:30:32 <river> to prove that something needs to be generated by a big program, you need to show that it cannot be generated by all ~2^n smaller programs
07:30:40 <shachaf> Hmm, I don't think this is omega-consistency.
07:30:44 <river> and 2^n is basically infinity?
07:31:17 <shachaf> Well, the issue is the halting problem.
07:31:34 <shachaf> You can run all those programs, and some of them will halt quickly, and some will halt after a long time, and some will never halt.
07:31:43 <shachaf> And you can't tell the latter two apart.
07:32:24 <river> so there's some scary programs in there
07:32:39 <river> ones that do not halt
07:32:43 <river> but cannot be proven to not halt
07:33:12 <shachaf> Hmm, the ones that don't halt may not be the ones to be scared of.
07:33:26 <shachaf> How small do you think the smallest program that can trick you is?
07:33:39 <river> probably smaller than i'd expect
07:34:01 <shachaf> 3 bytes of x86-64 was enough for me.
07:34:33 <shachaf> Someone here asked about 3-byte sequences to set a register to -1.
07:34:48 <shachaf> So I did a brute-force search over all 256^3 sequences.
07:35:09 <shachaf> And there were a bunch of surprising things, like programs cheating in various ways.
07:35:27 <shachaf> (Managing to return success for the test even though they didn't actually set the register to -1.)
07:35:52 <shachaf> There were all sorts of weird crashes, the thing forking itself in ways I was trying to prevent and failed, all sorts of things.
07:37:00 <river> I always wanted to run a survey for termination proofs for all short programs
07:37:05 <river> with the aim of finding hard ones to prove
07:37:14 <shachaf> I should write it up, it was pretty good.
07:37:22 <river> i would love to read about it!
07:37:38 -!- monoxane0 has joined.
07:39:52 -!- monoxane has quit (Ping timeout: 272 seconds).
07:39:53 -!- monoxane0 has changed nick to monoxane.
07:48:14 <river> http://www.ams.org/notices/201011/rtx101101454p.pdf
07:48:25 <river> so far we discussed the 1st incompleteness theorem
07:48:38 <river> the 2nd theorem comes from an adaptation of the surprise examination paradox
08:14:35 -!- monoxane3 has joined.
08:16:32 -!- monoxane has quit (Ping timeout: 255 seconds).
08:16:32 -!- monoxane3 has changed nick to monoxane.
08:39:14 -!- monoxane8 has joined.
08:39:56 -!- monoxane has quit (Ping timeout: 244 seconds).
08:39:57 -!- monoxane8 has changed nick to monoxane.
09:34:22 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97744&oldid=97742 * Z Ling * (+72)
09:36:45 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97745&oldid=97744 * Z Ling * (+42)
09:58:50 <esolangs> [[OISC:3]] M https://esolangs.org/w/index.php?diff=97746&oldid=96056 * McChuck * (+18)
10:00:09 <esolangs> [[OISC:2bis]] M https://esolangs.org/w/index.php?diff=97747&oldid=96062 * McChuck * (+18)
10:06:25 <esolangs> [[OISC:2bis]] M https://esolangs.org/w/index.php?diff=97748&oldid=97747 * McChuck * (+1) /* Summary */
10:07:43 -!- __monty__ has joined.
10:08:32 <esolangs> [[OISC:2bis]] M https://esolangs.org/w/index.php?diff=97749&oldid=97748 * McChuck * (+16) /* Summary */
11:00:36 -!- monoxane7 has joined.
11:01:42 -!- monoxane has quit (Ping timeout: 260 seconds).
11:01:42 -!- monoxane7 has changed nick to monoxane.
11:18:25 -!- littlebobeep has joined.
11:22:07 -!- Hoolootwo has joined.
11:25:34 -!- littlebobeep has quit (Ping timeout: 240 seconds).
11:37:07 -!- littlebobeep has joined.
11:56:05 -!- monoxane4 has joined.
11:58:18 -!- monoxane has quit (Ping timeout: 276 seconds).
11:58:18 -!- monoxane4 has changed nick to monoxane.
12:06:39 <esolangs> [[Gino]] M https://esolangs.org/w/index.php?diff=97750&oldid=97745 * Z Ling * (-13) /* */
12:12:14 -!- tech_exorcist has joined.
12:33:26 -!- Thedarkb-Desktop has joined.
12:51:49 -!- archenoth has quit (Remote host closed the connection).
12:52:14 -!- archenoth has joined.
12:57:56 <esolangs> [[Self-interpreter]] N https://esolangs.org/w/index.php?oldid=97751 * Peter * (+104) Created page with "{{stub}} A '''self-interpreter''' is an [[interpreter]] written in the same language that it interprets."
13:34:04 -!- littlebobeep has quit (Ping timeout: 240 seconds).
13:52:05 -!- Cale has quit (Ping timeout: 258 seconds).
13:52:44 -!- Cale has joined.
14:25:49 <esolangs> [[Bundle]] https://esolangs.org/w/index.php?diff=97752&oldid=97598 * Lanksy * (+112) /* Commands */
14:31:35 -!- Sgeo has joined.
14:41:00 <esolangs> [[Self-interpreter]] M https://esolangs.org/w/index.php?diff=97753&oldid=97751 * Corbin * (+1423) Category, blurb.
14:57:13 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97754&oldid=97715 * PixelatedStarfish * (-290) /* Updates */
14:57:42 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97755&oldid=97754 * PixelatedStarfish * (+21) /* Updates */
15:20:18 <esolangs> [[]] M https://esolangs.org/w/index.php?diff=97756&oldid=97733 * PythonshellDebugwindow * (+24) Add category
15:24:54 <esolangs> [[Brain Ah Fuck]] M https://esolangs.org/w/index.php?diff=97757&oldid=97719 * PythonshellDebugwindow * (-19) Stub, categories
16:00:48 <Sgeo> "Note that I said that an assembly programmer can generate better code than a compiler, not will generate better code. While it is true that good assembly code is better than good compiled code, it is also true that bad assembly code is often much worse than bad compiled code; since the assembly programmer has so much control over the program, he or she has virtually unlimited opportunities to waste cycles and bytes. The sword cuts both ways, and good assembly
16:00:48 <Sgeo> code requires more, not less, forethought and planning than good code written in a high-level language."
16:04:26 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97758&oldid=97755 * PixelatedStarfish * (+1269) /* Design Goals: Why Use BunnyBell? */
16:05:35 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97759&oldid=97758 * PixelatedStarfish * (-21) /* Design Goals: Why Use BunnyBell? */
16:06:00 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97760&oldid=97759 * PixelatedStarfish * (-11) /* Design Goals: Why Use BunnyBell? */
16:06:29 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97761&oldid=97760 * PixelatedStarfish * (+10) /* Design Goals: Why Use BunnyBell? */
16:08:39 <int-e> Sgeo: . o O ( And then the next CPU generation comes along and invalidates all the optimization choices you made. )
16:09:35 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97762&oldid=97761 * PixelatedStarfish * (+2) /* Cat (Echo) */
16:10:00 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97763&oldid=97762 * PixelatedStarfish * (-259) /* Cat (Echo) */
16:10:41 <int-e> It's not that the claim is false; it's hard to justify the effort for the increasingly meager gains from diving into assembly, except when the compiler actually does something stupid. (register allocation is far from perfect; manual assembly code can sometimes avoid spills, and that can actually pay off. vectorization is also a weak spot but the first step in that case is to use intrinsics)
16:14:15 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97764&oldid=97763 * PixelatedStarfish * (+0) /* Error Codes */
16:23:07 <b_jonas> this, yes. it's worth to understand how the CPU works, especially the cache hierarchy, and all the basics before that, if you want to write good high-level code, but you very rarely have to write assembly code instead of telling the compiler the right hints.
16:24:07 <esolangs> [[Deadfish]] https://esolangs.org/w/index.php?diff=97765&oldid=97701 * Tux1 * (+1859)
16:29:56 <esolangs> [[Deadfish]] https://esolangs.org/w/index.php?diff=97766&oldid=97765 * Tux1 * (+184)
16:30:04 -!- littlebobeep has joined.
16:47:34 -!- littlebobeep has quit (Ping timeout: 240 seconds).
17:04:02 -!- littlebobeep has joined.
17:08:34 -!- littlebobeep has quit (Ping timeout: 240 seconds).
17:22:55 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97767&oldid=97764 * PixelatedStarfish * (+2421) /* Proof by Translation to bf */
17:29:26 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97768&oldid=97767 * PixelatedStarfish * (+337) /* Algorithm */
17:29:40 -!- littlebobeep has joined.
17:30:04 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97769&oldid=97768 * PixelatedStarfish * (+6) /* =Bell */
17:30:18 <esolangs> [[Self-interpreter]] https://esolangs.org/w/index.php?diff=97770&oldid=97753 * Peter * (-10)
17:30:44 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97771&oldid=97769 * PixelatedStarfish * (+2) /* Address */
17:31:04 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97772&oldid=97771 * PixelatedStarfish * (-1) /* Index */
17:33:40 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97773&oldid=97772 * PixelatedStarfish * (+99) /* Bug */
17:34:01 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97774&oldid=97773 * PixelatedStarfish * (+2) /* Bug */
17:35:31 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97775&oldid=97774 * PixelatedStarfish * (-190) /* Stack Overflow */
17:36:48 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97776&oldid=97775 * PixelatedStarfish * (+186) /* Proof by Translation to bf */
17:37:58 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97777&oldid=97776 * PixelatedStarfish * (+4) /* Bug */
17:38:54 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97778&oldid=97777 * PixelatedStarfish * (-1) /* Comment */
17:39:48 <esolangs> [[Zetta]] N https://esolangs.org/w/index.php?oldid=97779 * Masalt * (+145) Created page with "{{stub}} {{WIP}} Zetta is an awful [[brainf***]] derivative. ==[[Popular problem|Examples]]== ===[[Hello World]]=== Hello World[<]>,,,,,,,,,,,"
17:53:33 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97780&oldid=97778 * PixelatedStarfish * (+414) /* Bell */
17:53:58 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97781&oldid=97780 * PixelatedStarfish * (+2) /* Bell */
17:56:10 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97782&oldid=97781 * PixelatedStarfish * (+108) /* EBNF */
17:58:27 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97783&oldid=97782 * PixelatedStarfish * (+83) /* Stack Overflow */
18:13:17 -!- Thedarkb-Desktop has quit (Read error: Connection reset by peer).
18:13:36 -!- Thedarkb-Desktop has joined.
18:16:04 -!- littlebobeep has quit (Ping timeout: 240 seconds).
18:24:10 -!- littlebobeep has joined.
18:26:12 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97784&oldid=97783 * PixelatedStarfish * (+71) /* Call */
18:31:07 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97785&oldid=97784 * PixelatedStarfish * (+286) /* Heap */
18:32:47 -!- monoxane6 has joined.
18:33:19 -!- monoxane has quit (Ping timeout: 256 seconds).
18:33:20 -!- monoxane6 has changed nick to monoxane.
18:36:26 <esolangs> [[Zetta]] https://esolangs.org/w/index.php?diff=97786&oldid=97779 * Masalt * (+117)
18:37:10 <esolangs> [[User:Masalt]] https://esolangs.org/w/index.php?diff=97787&oldid=97732 * Masalt * (+11) /* Languages */
18:38:31 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97788&oldid=97785 * PixelatedStarfish * (+184) /* Error */
18:42:09 -!- monoxane has quit (Ping timeout: 246 seconds).
18:42:33 -!- monoxane9 has joined.
18:54:23 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97789&oldid=97788 * PixelatedStarfish * (+19) /* Error */
18:58:55 -!- monoxane has joined.
18:58:58 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97790&oldid=97789 * PixelatedStarfish * (+245) /* Stack */
19:00:30 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97791&oldid=97790 * PixelatedStarfish * (+57) /* Function */
19:01:20 -!- monoxane9 has quit (Ping timeout: 272 seconds).
19:03:46 <esolangs> [[Zetta]] https://esolangs.org/w/index.php?diff=97792&oldid=97786 * Masalt * (-8)
19:17:31 -!- vyv has joined.
19:25:15 <esolangs> [[User:Masalt]] https://esolangs.org/w/index.php?diff=97793&oldid=97787 * Masalt * (-1) /* Coming Soon */
19:43:25 -!- monoxane1 has joined.
19:44:10 -!- monoxane has quit (Ping timeout: 240 seconds).
19:44:11 -!- monoxane1 has changed nick to monoxane.
19:47:45 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] N https://esolangs.org/w/index.php?oldid=97794 * Masalt * (+378) Created page with "DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE is a language made by [[User:Masalt]] in Python 3. ==[[Popular problem|Example Programs]] ===[[Hello World]]=== DONT YOU..."
19:47:58 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] https://esolangs.org/w/index.php?diff=97795&oldid=97794 * Masalt * (+2)
19:48:28 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] https://esolangs.org/w/index.php?diff=97796&oldid=97795 * Masalt * (+17)
19:49:39 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97797&oldid=97791 * PixelatedStarfish * (+379) /* ASCII Table */
20:00:42 -!- vyv has quit (Quit: Konversation terminated!).
20:10:32 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97798&oldid=97797 * PixelatedStarfish * (-11) /* Syntax */
20:14:34 -!- littlebobeep has quit (Ping timeout: 240 seconds).
20:18:04 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97799&oldid=97798 * PixelatedStarfish * (+218) /* Stack Overflow */
20:18:53 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] https://esolangs.org/w/index.php?diff=97800&oldid=97796 * Masalt * (+16) /* Example Programs */
20:19:03 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] https://esolangs.org/w/index.php?diff=97801&oldid=97800 * Masalt * (-1) /* Cat Program */
20:24:11 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] https://esolangs.org/w/index.php?diff=97802&oldid=97801 * Masalt * (-6) /* Example Programs */
20:24:58 -!- monoxane5 has joined.
20:26:23 -!- littlebobeep has joined.
20:26:44 -!- monoxane has quit (Ping timeout: 244 seconds).
20:26:45 -!- monoxane5 has changed nick to monoxane.
20:28:59 -!- Thedarkb-Desktop has quit (Remote host closed the connection).
20:30:30 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97803&oldid=97799 * PixelatedStarfish * (+538) /* Bell */
20:30:49 -!- tech_exorcist has quit (Quit: Disconnecting).
20:32:51 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97804&oldid=97803 * PixelatedStarfish * (+39) /* Bug */
20:33:10 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97805&oldid=97804 * PixelatedStarfish * (-1) /* Bug */
20:36:04 -!- littlebobeep has quit (Ping timeout: 240 seconds).
20:36:40 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97806&oldid=97805 * PixelatedStarfish * (+247) /* Heap */
20:37:14 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97807&oldid=97806 * PixelatedStarfish * (-1) /* Parent */
20:39:11 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97808&oldid=97807 * PixelatedStarfish * (+93) /* Heap */
20:39:14 <esolangs> [[Deadfish]] https://esolangs.org/w/index.php?diff=97809&oldid=97766 * Tux1 * (+0)
20:41:45 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97810&oldid=97808 * PixelatedStarfish * (+39) /* Integer */
20:43:21 -!- littlebobeep has joined.
20:43:27 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97811&oldid=97810 * PixelatedStarfish * (+94) /* Integer */
20:47:16 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97812&oldid=97811 * PixelatedStarfish * (+25) /* Long */
20:56:42 -!- monoxane2 has joined.
20:57:27 -!- monoxane has quit (Ping timeout: 240 seconds).
20:57:27 -!- monoxane2 has changed nick to monoxane.
20:59:03 <esolangs> [[DONT YOU LECTURE ME WITH YOUR THIRTY DOLLAR LANGUAGE]] https://esolangs.org/w/index.php?diff=97813&oldid=97802 * Masalt * (+107) /* Example Programs */
21:08:35 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97814&oldid=97812 * PixelatedStarfish * (+10) /* Updates */
21:09:00 <esolangs> [[Brain Ah Fuck]] https://esolangs.org/w/index.php?diff=97815&oldid=97757 * Xarthan * (+475) i went to bed
21:09:26 <esolangs> [[Brain Ah Fuck]] M https://esolangs.org/w/index.php?diff=97816&oldid=97815 * Xarthan * (+0) error fixed
21:10:07 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97817&oldid=97814 * PixelatedStarfish * (-87) /* Bell */
21:11:36 -!- monoxane3 has joined.
21:12:31 -!- monoxane has quit (Ping timeout: 258 seconds).
21:12:32 -!- monoxane3 has changed nick to monoxane.
21:20:24 -!- monoxane8 has joined.
21:21:51 -!- monoxane has quit (Ping timeout: 276 seconds).
21:21:51 -!- monoxane8 has changed nick to monoxane.
21:27:18 <esolangs> [[RunR]] https://esolangs.org/w/index.php?diff=97818&oldid=94826 * Stasoid * (+0) make hello world print a space instead of NUL
21:35:46 -!- monoxane5 has joined.
21:36:55 -!- monoxane has quit (Ping timeout: 256 seconds).
21:36:56 -!- monoxane5 has changed nick to monoxane.
21:42:25 <esolangs> [[RunR]] https://esolangs.org/w/index.php?diff=97819&oldid=97818 * Stasoid * (-68) fix the spec to match actual behavior of the interpreter
21:45:57 -!- __monty__ has quit (Quit: leaving).
21:46:58 -!- monoxane4 has joined.
21:49:09 -!- monoxane has quit (Ping timeout: 276 seconds).
21:49:09 -!- monoxane4 has changed nick to monoxane.
21:49:11 -!- definitelya has quit (Quit: h).
21:56:13 -!- monoxane9 has joined.
21:57:33 <esolangs> [[Talk:RunR]] https://esolangs.org/w/index.php?diff=97820&oldid=58849 * Stasoid * (+184)
21:58:15 -!- monoxane has quit (Ping timeout: 276 seconds).
21:58:15 -!- monoxane9 has changed nick to monoxane.
22:12:13 -!- monoxane6 has joined.
22:12:51 -!- monoxane has quit (Ping timeout: 246 seconds).
22:12:52 -!- monoxane6 has changed nick to monoxane.
22:13:51 <esolangs> [[Brain Ah Fuck]] https://esolangs.org/w/index.php?diff=97821&oldid=97816 * Xarthan * (+236) instructions
22:15:46 <esolangs> [[A?b.]] https://esolangs.org/w/index.php?diff=97822&oldid=95620 * Masalt * (+3)
22:18:17 <esolangs> [[A?b.]] https://esolangs.org/w/index.php?diff=97823&oldid=97822 * Masalt * (-2)
22:19:27 -!- monoxane3 has joined.
22:20:08 <esolangs> [[Zetta]] https://esolangs.org/w/index.php?diff=97824&oldid=97792 * Masalt * (+24)
22:20:10 -!- monoxane has quit (Ping timeout: 240 seconds).
22:20:11 -!- monoxane3 has changed nick to monoxane.
22:21:02 -!- ais523 has joined.
22:21:08 <ais523> <zzo38> Is C-INTERCAL capable of using the PEXT instruction of x86? ← yes, it is
22:22:04 <ais523> re: humans beating compilers, one big advantage for the humans is that they can change the meaning of the code when optimising, because they know it will be equivalent
22:23:24 <ais523> register spilling is such a weird topic on modern processors – they have easily enough registers but can run out of register *names*, so you spill the register just to have some way to refer to it
22:23:51 <esolangs> [[Zetta]] https://esolangs.org/w/index.php?diff=97825&oldid=97824 * Masalt * (+156)
22:23:56 <ais523> it seems so wasteful – perhaps a subset of memory addresses should be reserved to refer to registers beyond the normal 16
22:24:23 <esolangs> [[Zetta]] https://esolangs.org/w/index.php?diff=97826&oldid=97825 * Masalt * (+17)
22:24:33 <ais523> that could even be made forwards-compatible by mapping the addresses
22:25:34 <esolangs> [[RunR]] https://esolangs.org/w/index.php?diff=97827&oldid=97819 * Stasoid * (+55) /* External resources */
22:25:55 -!- monoxane3 has joined.
22:26:08 -!- monoxane has quit (Ping timeout: 255 seconds).
22:26:08 -!- monoxane3 has changed nick to monoxane.
22:27:27 <esolangs> [[Self-interpreter]] https://esolangs.org/w/index.php?diff=97828&oldid=97770 * Ais523 * (+187) /* Folklore */ why a self-interpreter doesn't prove Turing-completeness
22:27:42 <esolangs> [[Category:Bad]] N https://esolangs.org/w/index.php?oldid=97829 * Masalt * (+42) Created page with "The category of objectively bad languages."
22:29:23 <esolangs> [[Special:Log/delete]] delete * Ais523 * deleted "[[Category:Bad]]": unapproved category
22:29:38 <ais523> Corbin: I'm not convinced that homoiconicity is required for an interpreter to be metacircular; for example, https://esolangs.org/wiki/Advance_The_Wheel! has a metacircular data pointer which is completely unrelated to the syntax
22:30:00 <ais523> (the exclamation mark is part of the link but some clients may treat it as separate, so the link may be broken)
22:30:22 <esolangs> [[Advance The Wheel]] N https://esolangs.org/w/index.php?oldid=97830 * Ais523 * (+32) punct redir
22:32:02 <Corbin> ais523: I didn't mean to take a controversial stance. Feel free to change it.
22:32:23 <ais523> Corbin: I don't think it is necessarily controversial – this is a topic that I'm not sure I fully understand myself
22:33:11 <ais523> hmm, I guess the way I'm thinking about this is, in an interpreter, each element of the program being interpreted has to be represented as something in the interpreting program
22:33:47 <ais523> e.g. in the ATW! self-interpreter, the wheel position is represented as the instruction pointer, the instruction pointer and program are represented as queue 1, the data pointer is represented as the data pointer
22:33:58 <ais523> and the case of something being represented as itself is an interesting special case
22:34:34 <ais523> metacircularity is related to this special case, but I'm not sure that it's the same
22:36:20 <esolangs> [[Brain Ah Fuck]] https://esolangs.org/w/index.php?diff=97831&oldid=97821 * Xarthan * (+550) Hello, world! and some instructions clarifications and punctuations
22:37:29 <esolangs> [[Brain Ah Fuck]] M https://esolangs.org/w/index.php?diff=97832&oldid=97831 * Xarthan * (-8) oops
22:37:35 -!- Hoolootwo has quit (Quit: ZNC 1.7.5+deb4 - https://znc.in).
22:38:53 -!- monoxane6 has joined.
22:39:36 -!- Hooloovoo has joined.
22:39:50 -!- monoxane has quit (Ping timeout: 240 seconds).
22:39:51 -!- monoxane6 has changed nick to monoxane.
22:41:06 <ais523> actually I'm not convinced that anyone knows what metacircularity actually is
22:41:27 <esolangs> [[Brain Ah Fuck]] M https://esolangs.org/w/index.php?diff=97833&oldid=97832 * Xarthan * (-12) added wip
22:41:40 <ais523> there are some things which are clearly metacircular, but there's a lot of grey area too and it's unclear where the boundaries of the definition are
22:43:40 <ais523> hmm, maybe ATW! actually is homoiconic? in that the interpreter operates on source code directly, it doesn't parse it at all (because the source format is so simple that it doesn't need parsing)
22:46:40 <zzo38> I read that GCC has some built-in functions that use PEXT and other instructions if a flag is specified; how can you detect those flags by preprocessor?
22:47:42 <ais523> zzo38: Intel and AMD recommend looking for the flag in question at runtime, rather than compile time – there is a CPU instruction to return the flags
22:48:06 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97834&oldid=97817 * PixelatedStarfish * (+181) /* Syntax */
22:48:51 -!- monoxane1 has joined.
22:48:59 <ais523> there don't seem to be any predefined #defines with GNU cpp that lists them
22:49:02 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97835&oldid=97834 * PixelatedStarfish * (+77) /* Turing Complete */
22:50:17 <ais523> there's an attribute to assume certain flags when compiling a function
22:50:40 -!- monoxane has quit (Ping timeout: 258 seconds).
22:50:40 -!- monoxane1 has changed nick to monoxane.
22:50:51 <ais523> but I guess the issue is that you're supposed to tell gcc whether it's allowed to use instructions like PEXT and PDEP, rather than it telling you, as it's you rather than it that knows which processors might run the resulting executable
22:54:46 <zzo38> Yes, although you might want to put in your own optimizations that use such instructions if they are enabled, especially if you want to make it compatible with older versions of the compiler, or other target computers which might not have such instructions, etc.
22:56:08 <ais523> Rust has a conditional compliation attribute (similar to a preprocessor directive) to compile something only if certain instructions are enabled – it would make sense for GNU C to have one too, but I haven't been able to find it
22:56:48 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=97836&oldid=97690 * Masalt * (+34)
22:57:10 <ais523> zzo38: aha, there's __builtin_cpu_supports
22:57:32 <ais523> so in this case, it'd be __builtin_cpu_supports("bmi2")
22:57:34 <b_jonas> "<ais523> perhaps a subset of memory addresses should be reserved to refer to registers beyond the normal 16" => how would that be different from the current situation where you use addresses relative to the stack pointer for extra temporary values, since accessing those has a compact encoding with a 1-byte offset, and better and better optimizations in the cpu for accessing them?
22:57:45 <ais523> but, that's a runtime detection, rather than compile-time, it returns the correct value for the actual processor
22:57:57 <ais523> so it needs to be used in an if statement rather than by the preprocessor
22:58:13 <ais523> b_jonas: it wouldn't actually youch memory
22:58:31 <ais523> that means that you aren't tying up memory read/write ports
22:58:46 <zzo38> The other way, then, would be that you will have to add them by yourself (by using -D), but this isn't as good since it cannot be used e.g. if you specify to target the same computer that it is being compiled on automatically.
22:59:55 <ais523> there does seem to be a use case for this, but either gcc doesn't have a way to do it, or I can't find it
23:00:04 -!- littlebobeep has quit (Ping timeout: 240 seconds).
23:02:50 <b_jonas> "<ais523> actually I'm not convinced that anyone knows what metacircularity actually is" => Douglas Hofstadter might know; Raymond Smullyan probably did know but he passed away in 2017
23:03:27 <b_jonas> or maybe they knew why you can't draw a boundary
23:04:15 <ais523> something I've been thinking about recently: suppose you have a self-interpreter with extensions, i.e. it interprets the language it's written in plus a few extra custom commands
23:04:38 -!- monoxane9 has joined.
23:04:51 <ais523> if parts of the design are table-driven rather than hard-coded, you can add commands to change those tables
23:05:00 <ais523> and it's easy to add commands that change the program being interpreted
23:05:18 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97837&oldid=97835 * PixelatedStarfish * (+96) /* Comment */
23:05:39 <ais523> this gives you a slightly extended version of the language, and an intepreter for it
23:06:06 <ais523> now, suppose you're writing a self-interpreter (or extended-self-interpreter) in that slightly extended version of the language, i.e. we're now two levels of self-interpreters deep
23:06:34 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97838&oldid=97837 * PixelatedStarfish * (+41) /* Error */
23:06:43 <ais523> this can be easily and efficiently implemented simply by reprogramming the running interpreter to have new commands (if necessary) and to be running a new program, and you end up with a self-interpreter with eigenratio 1
23:06:47 -!- monoxane has quit (Ping timeout: 260 seconds).
23:06:47 -!- monoxane9 has changed nick to monoxane.
23:07:26 <ais523> I guess the obvious question in the context of this conversation (and what prompted me to think about this again) is "is this metacircularity?"
23:10:40 <esolangs> [[Self-interpreter]] M https://esolangs.org/w/index.php?diff=97839&oldid=97828 * Ais523 * (+0) /* Folklore */ typo fix
23:10:49 <b_jonas> "<ais523> that means that you aren't tying up memory read/write ports" => I think very new CPUs can optimize it to not tie up memory read ports, if it notices while decoding that you're referencing the same offset and index register, without even knowing the address. it will tie up a memory write port, but generally only in the L1 cache because the top of the stack will be there, and that usually won't
23:10:55 <b_jonas> cause a delay unless you do a crazy amount of writes in a short time.
23:11:08 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97840&oldid=97838 * PixelatedStarfish * (+56) /* Stack */
23:12:16 <ais523> b_jonas: it's specifically AMD Zen 2 that could do that, and that's not the newest version
23:12:29 <ais523> the feature was removed for Zen 3, and IIRC Intel processors have never been able to do that
23:12:33 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97841&oldid=97840 * PixelatedStarfish * (+32) /* Function */
23:12:55 <ais523> also the L1 write limit is normally 1 write per cycle, which seems quite plausible to hit in some types of code
23:13:29 <ais523> (AMD Zen 3 can run 6 instructions per CPU cycle, and having more than ⅙ of the instructions do memory writes doesn't seem that unlikely)
23:13:35 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97842&oldid=97841 * PixelatedStarfish * (+48) /* Integer */
23:13:38 <b_jonas> however, if you are ok with using such a new cpu (and I presume you have to be if you're calling for a new feature) then you can also use 32 64-bit ZMM registers, though moving into them is of course much more expensive to encode than just a stack ref'ce
23:13:44 -!- sprout has quit (Read error: Connection reset by peer).
23:13:57 -!- sprout has joined.
23:14:28 <b_jonas> "(AMD Zen 3 can run 6 instructions per CPU cycle," => unlikely if those are referencing memory arguments
23:14:53 <ais523> b_jonas: indeed, there are other limits too
23:15:07 <b_jonas> though I guess that's exactly the problem that you're saying
23:15:58 <ais523> in practice, 16 registers (well, 15 – you normally don't want to mess with %rsp) usually seem to be enough
23:16:33 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97843&oldid=97842 * PixelatedStarfish * (+42) /* Long */
23:16:35 <ais523> the main exceptions are code with lots of nested function calls, but our existing ABIs force registers to be allocated inefficiently across functions anyway
23:17:04 <ais523> and of course, recursive code has no option but to spill registers
23:17:22 <ais523> (I realised a while ago that a function call is, in effect, just a spill of %rip)
23:20:07 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97844&oldid=97843 * PixelatedStarfish * (+44) /* Data Type */
23:21:30 <b_jonas> ok, stupid question, if you're doing vector integer calls on AVX, and you're running low on the 16 XMM register, is there a way to temporarily store or retrieve two 16-bit XMM values in a YMM register, similarly to how you can use an XMM to temporarily store two 64-bit general register values in an XMM reg with PINSRQ/PEXTRQ, only this time your XMM and YMM regs overlap?
23:22:39 <ais523> I'm pretty sure there's an instruction to move an XMM to the top half of a YMM, but if your program is almost entirely AVX, you shouldn't use it
23:22:44 <esolangs> [[BunnyBell Documentation]] https://esolangs.org/w/index.php?diff=97845&oldid=97844 * PixelatedStarfish * (+41) /* Error */
23:23:13 <ais523> err, * almost entirely XMM
23:23:20 <b_jonas> ais523: it's entirely AVX because mixing SSE2 and AVX instructions in optimized code can be a bad idea due to the SSE2 instructions having to keep the top half of YMM regs
23:23:53 <ais523> using the YMM registers switches the processor over to an alternative mode where it runs YMM-sized instructions more quickly but all other instructions more slowly
23:24:01 <b_jonas> you just use the AVX equivalents of all the SSE2 instructions. all or almost all the instructions have an AVX encoding so this isn't a problem.
23:24:28 <ais523> this is independent of the alternative modes for the top half of YMM registers being dirty
23:24:57 <b_jonas> but then how are you supposed to use YMM at all on AVX cpus?
23:25:16 <ais523> AVX has YMM-sized instructions for a lot of the basic functionality
23:25:21 <ais523> (and AVX2 added a lot more)
23:25:29 <b_jonas> yes, AVX2 probably solves this
23:25:33 <ais523> the intention is to use them for, e.g., big loops that are just doing simple additions on arrays
23:25:53 <ais523> so the processor switches over to a mode where it can add more numbers at once, but at the cost of performance elsewhere in the processor
23:26:05 <b_jonas> so you can't easily mix 16-bit vectors and 32-bit vectors, even if you encode everything in AVX or AVX2? why?
23:26:06 <ais523> AVX-512 is even more extreme – the processor has to reduce its clock speed to avoid overheating
23:26:40 <ais523> it's basically to do with heat dissipation, the less of the vector unit you use, the faster you can run without heating issues
23:27:20 <ais523> basically all the YMM instructions can be implemented by desugaring them into two XMM instructions (with hidden programmer-inaccessible annotations to use the top half of the XMM register)
23:27:37 -!- monoxane9 has joined.
23:27:40 <ais523> that's what processors do if they can't use the full vector unit (either because they're too hot or because they don't have a YMM-wide vector unit)
23:28:14 -!- monoxane has quit (Ping timeout: 255 seconds).
23:28:14 -!- monoxane9 has changed nick to monoxane.
23:28:16 <ais523> but if the processor sees YMM instructions, it actively tries to cool itself down so that the whole unit is usable, that means it needs to focus more on efficiency rather than speed for the other instructions it uses
23:28:57 <b_jonas> I guess it makes sense that if you can use 32-byte vectors then you should use them
23:29:20 <b_jonas> on AVX2 cpus like this one in my new computer
23:29:24 <ais523> anyway, this is why it's usually a bad idea to mix vector sizes – the optimal processor configuration for different sizes is different
23:30:28 <b_jonas> but do I understand correctly that if I am mixing the sizes, and I'm really only using 16 bytes of a 32-byte vector, then it's not worse too use a 16-byte but AVX-encoded instruction than to use a 32-byte instruction but then discard half of the result, right?
23:30:58 <b_jonas> it's just that everything will run in a slower 32-byte vector core
23:31:00 <ais523> right, XMM instructions will run just fine when mixed with YMM instructions
23:31:37 <ais523> they could be slower than XMM instructions that aren't mixed, but won't be slower than YMM instructions
23:32:18 <ais523> (this is assuming that you're using the zero-extending versions, to avoid false dependencies)
23:32:53 <b_jonas> yes, zero-extending from XMM to YMM is what the AVX encoding as opposed to SSE2 encoding means
23:32:59 <b_jonas> they have a fancier name...
23:33:20 <b_jonas> VEX for the AVX encoding I think
23:33:36 <ais523> VEX is the name of the prefix byte
23:34:00 <ais523> AVX-512 has its own new prefix byte, EVEX, and you can also EVEX-encode SSE and AVX instructions
23:34:32 <ais523> VEX encoding is at most one byte longer than SSE encoding – normally it's the same length or even shorter
23:34:37 <ais523> and EVEX is one byte longer than VEX
23:35:52 -!- monoxane4 has joined.
23:37:23 <b_jonas> are you sure? I thought that the VEX encoding can be one byte shorter than the SSE2 encoding in some cases, where the SSE2 encoding needs three prefix bytes (F0, a rex prefix, and an OS/REPNE/REP prefix, I don't know the correct order) whereas the VEX can need just two bytes of prefix
23:37:33 -!- monoxane has quit (Ping timeout: 246 seconds).
23:37:34 -!- monoxane4 has changed nick to monoxane.
23:37:34 <b_jonas> oh right, that's what you said
23:37:42 <b_jonas> "normally it's the same length or even shorter"
23:39:25 <ais523> I've actually pondered the merits of a compiler that generates SIMD versions of functions, so that they can be used in vectorized loops without inlining
23:39:56 <ais523> probably the implementation strategy is to generate SIMD by default, and then if it turns out that only a single "thread" is needed, to deSIMDify it by replacing the vector instructions with scalar instructions
23:40:16 <ais523> this would require using scatter/gather instructions a *lot*, though, so it might only be efficient on Intel
23:47:00 <b_jonas> ok, now I'm looking at the intel manual and somewhat confused by all these instruction encodings. which I suppose is normal, they are confusing.
23:53:55 -!- monoxane2 has joined.
23:54:10 -!- monoxane has quit (Ping timeout: 240 seconds).
23:54:11 -!- monoxane2 has changed nick to monoxane.