platform VS llvm-project

Compare platform vs llvm-project and see what are their differences.

llvm-project

The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. (by llvm)
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.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured
platform llvm-project
3 361
25 27,037
- 3.2%
10.0 10.0
about 3 years ago 1 day ago
LLVM
- GNU General Public License v3.0 or later
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

platform

Posts with mentions or reviews of platform. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-04-21.
  • Ask HN: Which books/resources to understand modern Assembler?
    6 projects | news.ycombinator.com | 21 Apr 2024
    The highload.fun wiki[0] links some resources. The intel optimization manual[1] is also useful.

    These resources are mostly aimed at solving problems for which compilers are not very useful, so there are probably other resources that are a better fit.

    [0]: https://github.com/Highload-fun/platform/wiki

    [1]: https://www.intel.com/content/www/us/en/content-details/6714...

  • SWAR find any byte from set
    2 projects | news.ycombinator.com | 8 Mar 2023
    The web site containing the article has a collection of other articles about this sort of thing. You can also read about this in some parts of Algorithms for Modern Hardware[0]. highload.fun includes some other links about this stuff[1]. In general there isn't a great guide and it's best to get your hands dirty. highload.fun happens to be a good place to do that :)

    [0]: https://en.algorithmica.org/hpc/algorithms/prefix/

    [1]: https://github.com/Highload-fun/platform/wiki

  • Cache invalidation is one of the hardest problems in computer science
    2 projects | news.ycombinator.com | 26 Nov 2022
    There are a lot of issues here, so I can share some stuff about some of them and hope that some helpful internet commenters come along and point out where I have neglected important things.

    A single modern CPU core is superscalar and has a deep instruction pipeline. With your help, it will decode and reorder many instructions and execute many instructions concurrently. Each of those instructions can operate on a lot of data.

    As famous online controversial opinion haver Casey Muratori tells us, most software just sucks, like really really bad (e.g. commonly people will post hash table benchmarks of high-performance hash tables that do bulk inserts in ~100ns/op, but you can do <10ns/op easily if you try), and using SIMD instructions is table stakes for making good use of the machinery inside of a single CPU core. SIMD instructions are not just for math! They are tools for general purpose programming, and when your program has unpredictable branches in it, it is often a lot cheaper to compute both branches and have a data dependency than to have a branch. Instructions like pshufb or blendv or just using a dang lookup table can replace branches. Wojciech Muła's web site[0] is the best collection of notes about using SIMD instructions for general-purpose programming, but I have found many of the articles to be incomplete or incorrect, and I have not yet done anything to fix the issue. "Using SIMD" ends up meaning that you choose the low-level layout of your data to be more suitable to processing using the instructions available, not just replacing the "glue code" and leaving the data the same as it was.

    Inside your single CPU core there is hardware for handling virtual -> physical address translation. This is a special cache called the translation lookaside buffer (TLB). Normally, chips other than recent Apple chips have a couple hundred entries of 1 4KiB page each in the TLB, and recent Apple chips have a couple hundred entries of 1 16KiB page each. Normal programs deal with a bit more than 1 meg of RAM today, and as a result they spend a huge portion of their execution time on TLB misses. You can fix this by using explicit huge pages on Linux. This feature nominally exists on Windows but is basically unusable for most programs because it requires the application to run as administrator and because the OS will never compact memory once it is fragmented (so the huge pages must be obtained at startup and never released, or they will disappear until you reboot). I have not tried it on Mac. As an example of a normal non-crazy program that is helped by larger pages, one person noted[1] that Linux builds 16% faster on 16K vs on 4K pages.

    Inside your single CPU core is a small hierarchy of set-associative caches. With your help, it will have the data it needs in cache almost all the time! An obvious aspect of this is that when you need to work on some data repeatedly, if you have a choice, you should do it before you have worked on a bunch of other data and caused that earlier data to be evicted (that is, you can rearrange your work to avoid "capacity misses"). A less obvious aspect of this is that if you operate on data that is too-aligned, you will greatly reduce the effective size of your cache, because all the data you are using will go into the same tiny subset of your cache! Famous online good opinion haver Dan Luu wrote about this here[2]. The links included in that post are also good resources for the topics you've asked about.

    When coordinating between multiple CPU cores, as noted in TFA, it is helpful to avoid false sharing[3]. People in industry have mostly found that it is helpful to avoid sharing *at all*, which is why they have work explicitly divided among cores and communicate over queues rather than dumping things into a concurrent hash map and hoping things work out. In general this is not a popular practice, and if you go online and post stuff like "Well, just don't allocate any memory after startup and don't pass any data between threads other than by using queues" you will lose imaginary internet points.

    There are some incantations you may want to apply if you would like Linux to prioritize running your program, which are documented in the Red Hat Low Latency Performance Tuning guide[4] and Erik Rigtorp's web site[5].

    Some other various resources are highload.fun[6], a web site where you can practice this sort of thing, a list of links associated with highload.fun[7], Sergey Slotin's excellent online book[8], and Dendi Bakh's online course[9] and blog[10].

    > Off topic: What level of sophistication about modern CPUs is _good_ to have?

    Probably none? These skills are basically unemployable as far as I can tell.

    [0]: http://0x80.pl/articles/index.html

    [1]: https://twitter.com/AtTheHackOfDawn/status/13338951151741870...

    [2]: https://danluu.com/3c-conflict/

    [3]: https://rigtorp.se/ringbuffer/

    [4]: https://access.redhat.com/sites/default/files/attachments/20...

    [5]: https://rigtorp.se/low-latency-guide/

    [6]: https://highload.fun/

    [7]: https://github.com/Highload-fun/platform/wiki

    [8]: https://en.algorithmica.org/hpc/

    [9]: https://github.com/dendibakh/perf-ninja

    [10]: https://easyperf.net/notes/

llvm-project

Posts with mentions or reviews of llvm-project. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-07-18.
  • Hash-Based Bisect Debugging in Compilers and Runtimes
    3 projects | news.ycombinator.com | 18 Jul 2024
    LLVM can bisect down to individual transformation steps within a pass (for passes that implement the interface): https://llvm.org/docs/OptBisect.html

    And there is a script bisecting functions when given assembly produced by working baseline and “bad” compiler to compare: https://github.com/llvm/llvm-project/blob/main/llvm/utils/ab...

  • Why you should keep an eye on Apache DataFusion and its community.
    4 projects | dev.to | 8 Jul 2024
    Similarly, LLVM revolutionized the world of programming languages and compilers. Since its creation, we've seen many new languages being created of increased complexity.
  • Guide on optimizing Linux kernel with BOLT
    1 project | news.ycombinator.com | 3 Jul 2024
  • Integrated assembler improvements in LLVM 19
    2 projects | news.ycombinator.com | 1 Jul 2024
    Side note, but I was looking for a pre-built binaries in releases of LLVM project. Specifically I was looking for clang+llvm releases for x86_64 linux (ubuntu preferably) in order to save some time (always had trouble compiling it) and to put it into my own `prefix` directory. It's kind of wild to see aarch64, armv7, powerpc64, x86_64_windows.. but not something like this. I am aware of https://apt.llvm.org/ and its llvm.sh - but as I said, I'd prefer it to live in its own `prefix`. Anyone knows where else there might be pre-builts? There used to be something just like that for v17, like https://github.com/llvm/llvm-project/releases/download/llvmo...
  • Compilers Are (Too) Smart
    2 projects | news.ycombinator.com | 9 Jun 2024
    The background here is that "ctpop < 2" or "ctpop == 1" (depending on zero behavior) is LLVM's canonical representation for a "power of two" check. It is used on the premise that the backend will expand it back into a cheap bitwise check and not use an actual ctpop operation. However, due to complex interactions in the backend, this does not actually happen in this case (https://github.com/llvm/llvm-project/issues/94829).
  • What errors are lurking in LLVM code?
    1 project | dev.to | 29 May 2024
    The checked project version is LLVM 18.1.0.
  • Qualcomm's Oryon LLVM Patches
    1 project | news.ycombinator.com | 15 May 2024
    I think they should probably set LoopMicroOpBufferSize to a non-zero value even if its not microarchitecturally accurate. This value is used in LLVM to control whether partial and runtime loop unrolling are enabled (actually only for that). Although some targets override this default behaviour, AArch64 only overrides it to enable partial and runtime unrolling for in-order models. I've left a review comment https://github.com/llvm/llvm-project/pull/91022/files#r16026... and as I note there, the setting seems to have become very divorced from microarchitectural reality if you look at how and why different scheduling models set it in-tree (e.g. all the Neoverse cores, set it to 16 with a comment they just copied it from the A57).
  • Yes, Ruby is fast, but…
    4 projects | dev.to | 9 May 2024
    In conclusion, none of the proposed changes to the Ruby version of the code makes a dent in the Crystal version. This is not entirely Crystal's doing: it uses the LLVM backend, which generates very optimized binaries.
  • Qt and C++ Trivial Relocation (Part 1)
    3 projects | news.ycombinator.com | 7 May 2024
    As far as I know, libstdc++'s representation has two advantages:

    First, it simplifies the implementation of `s.data()`, because you hold a pointer that invariably points to the first character of the data. The pointer-less version needs to do a branch there. Compare libstdc++ [1] to libc++ [2].

    [1]: https://github.com/gcc-mirror/gcc/blob/065dddc/libstdc++-v3/...

    [2]: https://github.com/llvm/llvm-project/blob/1a96179/libcxx/inc...

    Basically libstdc++ is paying an extra 8 bytes of storage, and losing trivial relocatability, in exchange for one fewer branch every time you access the string's characters. I imagine that the performance impact of that extra branch is tiny, and massively confounded in practice by unrelated factors that are clearly on libc++'s side (e.g. libc++'s SSO buffer is 7 bytes bigger, despite libc++'s string object itself being smaller). But it's there.

    The second advantage is that libstdc++ already did it that way, and to change it would be an ABI break; so now they're stuck with it. I mean, obviously that's not an "advantage" in the intuitive sense; but it's functionally equivalent to an advantage, in that it's a very strong technical answer to the question "Why doesn't libstdc++ just switch to doing it libc++'s way?"

  • Playing with DragonRuby Game Toolkit (DRGTK)
    2 projects | dev.to | 6 May 2024
    This Ruby implementation is based on mruby and LLVM and it’s commercial software but cheap.

What are some alternatives?

When comparing platform and llvm-project you can also consider the following projects:

perf-ninja - This is an online course where you can learn and master the skill of low-level performance analysis and tuning.

zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

ClickHouse - ClickHouse® is a real-time analytics DBMS

Lark - Lark is a parsing toolkit for Python, built with a focus on ergonomics, performance and modularity.

gcc

cosmopolitan - build-once run-anywhere c library

SDL - Simple Directmedia Layer

windmill - Open-source developer platform to turn scripts into workflows and UIs. Fastest workflow engine (5x vs Airflow). Open-source alternative to Airplane and Retool.

STL - MSVC's implementation of the C++ Standard Library.

Graal - GraalVM compiles Java applications into native executables that start instantly, scale fast, and use fewer compute resources 🚀

dmd - dmd D Programming Language compiler

rust - Empowering everyone to build reliable and efficient software.

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.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured

Did you konow that LLVM is
the 67th most popular programming language
based on number of metions?