fsfod

I wonder if you can also install it using dism /Apply-Image from an existing windows 10 installation skipping the need to run the installer.

Mike Pall is still working on LuaJIT just last week he pushed the first stage of string buffer support sponsored by some network company https://github.com/LuaJIT/LuaJIT/commit/4c6b669c419f313306b9...

The 2gb limit has been fixed for a many years now with the GC64 mode that was set to the default build mode last year.

Grub also has an optional module run to Lua code https://git.savannah.nongnu.org/cgit/grub-extras.git/tree/lu...

Are you gonna use the LuaJIT C VM RaptorJIT is working on https://github.com/raptorjit/raptorjit/pull/254 as a base to start from.

I'm also big fan of the LuaJIT compiler explorer you made https://luajit.me

It may not be exactly the same but Terra http://terralang.org/ uses Lua a meta programming language and the Terra language itself is effectively a typed Lua compiled to machine code with LLVM.

There is no 2GB limit if LuaJIT built in GC64 mode. It was an opt-in build time option until 13 days ago now its on default for 64 bit builds https://github.com/LuaJIT/LuaJIT/commit/bd00094c3b50e193fb32...

The last time Mike Paul pushed anything is almost a year ago until two weeks ago based on the two RSS feeds I use. The Git commit dates could be unreliable from either cherry-pick shenanigans or him just not bothering to push the changes until two weeks ago.

Some of the design of decisions that lead AVX512 are explained in these slides from Tom Forsyth http://tomforsyth1000.github.io/papers/LRBNI%20origins%20v4%... One of the reasons mentions is 512 bits is the same size as a cache line.

In theory you could do it directly with the intrinsic system I built for LuaJIT[1]. It would dynamically generated the assembly for a user declared intrinsic\arbitrary machine opcode when there first called in the interpreter and the opcode is directly emitted when the code is JIT'ed. I think defining an intrinsic for a system call would just be a matter of setting the correct input and output registers.

[1] https://github.com/LuaJIT/LuaJIT/pull/116

That's kind of one of the main uses of the API so far by QEMU for live migration of VMs by streaming memory on demand over a network https://wiki.qemu.org/Features/PostCopyLiveMigration

The write protected mode[1], if it ever gets merged could have some interesting uses for GCs.

[1] https://lore.kernel.org/patchwork/cover/1033856/

Its disappointing that AMD didn't bother to implement the 15H CPUID leaf that Intel added years ago to get the exact CPU TSC frequency. Yet AMD cared enough to add there own instruction(RDPRU) to get the values of APERF and MPERF in user mode.

Clang\LLVM has some heuristics where it will convert cmovs generated by earlier passes back in to jumps https://reviews.llvm.org/D34769. Also the compilers can't always prove its safe to evaluate both sides of a ternary operator which would be needed to use a cmov. Here's a compiler explorer sample for clang and GCC that shows all these problems https://godbolt.org/z/IpZfZv, you change the -x86-cmov-converter option to true re-enable clangs cmov converter which will disable cmov in the last function.

They did start out with a shared atom model for all three platforms but switched away from to separate implementations for ELF and COFF http://lists.llvm.org/pipermail/llvm-dev/2015-May/085088.htm...

The effect still exists in some way in later version windows like the Windows Volume Mixer will freeze up or won't open if you have an application stopped at a breakpoint. I think it gets stuck waiting for a reply from something like WM_GETICON that it would have to send to top-level windows.

As the co-author of that blog post a more accurate tl;dr would be the variance comes from shared hot counters that collide based on the address of objects.

There are some ugly hacks[0] to run 64 bit code in a 32 bit process on windows by using retf switch to 64 bit code segment with one of the major limitations being you can't load 64 dlls into the process.

[0]: http://blog.rewolf.pl/blog/?p=102

Well someone was crazy enough to port LuaJIT to run in the FreeBSD kernel including the JIT by the looks of it.

http://dl.acm.org/citation.cfm?id=2818305 http://ake.in.th/2016/01/09/til-there-is-a-tool-named-diffst...

This seems to be the post it was referring to http://lua-users.org/lists/lua-l/2011-02/msg00742.html

I remember Andy Glew discussing a little bit of the history of the behaviour of REP MOVS microcode in the comments of this stack overflow question http://stackoverflow.com/questions/8858778/why-are-complicat...

While trying to implement the new LuaJIT GC one of the things I tested adding early on was support for explicitly creating arenas from Lua and setting the 2 active arenas allocations happen from to support this kind of allocation patten. The minor GC mode also work well with this patten only having to touch modified objects and only sweeping away fresh white objects.