-
Smalltalk
Parser, code model, interpreter and navigable browser for the original Xerox Smalltalk-80 v2 sources and virtual image file (by rochus-keller)
-
InfluxDB
Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
-
benchmark-language
BENCHMARK: Lua vs vs LuaJIT vs C (MSVC, GCC, LLVM) vs Java vs Perl vs Javascript vs Python vs C# (.NET CLR, Mono) vs Ruby vs R
-
SaaSHub
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
What makes you so sure? This one demonstrates that the LuaJIT based version of the application runs nearly the same speed as the C++ version: https://github.com/rochus-keller/Smalltalk#a-smalltalk-80-interpreted-virtual-machine-on-luajit. This one demonstrates, that the LuaJIT based version of some of the benchmarks are even faster than the natively compiled version: https://github.com/rochus-keller/Oberon/blob/master/testcases/Hennessy_Results.
A tracing JIT can in principle beat an ahead-of-time compiled C program as the traces can run crosswise along different procedures without context switch and thus save at least this time. Have a look at these results: https://github.com/rochus-keller/Oberon/blob/master/testcases/Hennessy_Results. OBNC is an Oberon compiler which transpiles to C which is then ahead-of-time compiled using the common GCC optimizations; if you compare with the latest entry on line 75ff you see that the Oberon to LuaJIT bytecode compiled code performs better in some benchmarks (and worse in others); and OBNLC has not yet exploited all optimization possibilities.
It depends on the workload. LuaJIT is not always faster than C, but almost always in the same ballpark. Here is one example of LuaJIT being faster than gcc (albeit a bit synthetic in nature), and here is an example of LuaJIT being head-to-head with various C compilers.
WATT is a WASM JIT runtime to JIT Rust's procedural macros. Hence Rust would be a JITted language.
This is a completely different kind of measurement; unfortunately this is not clear enough from my Readme. I wanted to find out, how well my naive Bluebook interpreter performs on LuaJIT (using my virtual meta tracing approach) compared to Cog, which is a dedicatd Smalltalk VM optimized with whatever genious approaches over two decades (or even longer considering the long experience record by Elliot). This experiment continues in https://github.com/rochus-keller/Som, because I didn't want to modify the original Smalltalk image. I found that my naive LuaJIT based approach is about factor seven behind the highly optimized Cog/Spur, and further improvements would require similar optimization tricks as in the latter.