42nd-at-threadmill

A SIMD-accelerated concurrent hash table. (by telekons)

42nd-at-threadmill Alternatives

Similar projects and alternatives to 42nd-at-threadmill based on common topics and language

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better 42nd-at-threadmill alternative or higher similarity.

42nd-at-threadmill reviews and mentions

Posts with mentions or reviews of 42nd-at-threadmill. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2021-10-12.
  • Share a hash table with SBCL and Allegro Serve
    3 projects | /r/Common_Lisp | 12 Oct 2021
  • Revisiting Prechelt’s paper comparing Java, Lisp, C/C++ and scripting languages
    2 projects | news.ycombinator.com | 9 Aug 2021
    I agree that "C/C++" isn't a good sign, though it was more forgivable when C++ just meant C++98... For speed, nowadays, you use X. That is, many languages can be fast, especially if they have access to intrinsics, the real question is how much special knowledge and herculean effort do you have to spend? It's still true that for many problems idiomatic modern C++ will give a very nice result that may be hard to beat (though be careful if you forgot cin.sync_with_stdio(false) or you may be slower than Python!). But it's also true that C, Rust, Java, Common Lisp, and even JS all do very well out of the box these days, while languages like Python and Ruby have lagged. For this problem, the author had to spend quite a bit of effort in a followup post to get Rust to match some 20 year old unoptimized CL.

    If one wanted to optimize Lisp, a simple place to start is with some type declarations (at least with SBCL). It can even be kind of fun to have the compiler yell at you because e.g. it couldn't infer a type somewhere and was forced to do a generic add, so you tell it some things are fixnums, see the message go away, and verify if you want with DISASSEMBLE that it's now using LEA instead of a CALL. For an example of going to quite a bit of trouble (relatively) with adding inline hints, removing unneeded array bounds checks, and SIMD instructions, see https://github.com/telekons/42nd-at-threadmill which I believe is quite a bit faster than a similar "blazing fast" Rust project featured on HN not long ago. But my point again isn't so much that CL is the fastest or has some fast projects, just that it can be made as fast as you're probably going to want. This applies to a lot of other languages too, though CL still feels pretty unique in supporting both high level and low level constructs.

    Your GC comment is weird, since any publications looking at total performance invariable include the GC overhead, nothing is hidden. The TIME macro for micro-benchmarking even typically reports on allocated memory, which can be a proxy for estimating GC pressure, and both SBCL and CCL report the actual time (if any) spent in GC. Why not complain that C++ benchmarks hide the indirect costs of memory fragmentation, which is a real bane for long-running C++ programs like application servers? But I'll admit that the GC can be a big weakness and it's no fun to be forced to code around its limitations, and historically some GCs used by some Lisps were really bad (that is, huge pause times). I've been looking at the herculean GC work being done in the Java ecosystem for years with a jealous eye, and even the newer Nim with its swappable GCs when you want to make certain tradeoffs without having to code them in.

Stats

Basic 42nd-at-threadmill repo stats
4
56
0.0
over 1 year ago

telekons/42nd-at-threadmill is an open source project licensed under BSD 2-clause "Simplified" License which is an OSI approved license.

The primary programming language of 42nd-at-threadmill is Common Lisp.

SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com