Thread

Jemalloc 5.4.0

331 points · 94 comments · gkfasdfasdf

Loading the complete thread in the background. This saved snapshot is available now. Refresh

ZenoArrow · 1789711216 · focus · HN ↗
Why is this on the HN front page? Is there something particularly noteworthy about this release?
1. aktenlage · 1789711418 · focus · HN ↗
  They resumed development on jemalloc only recently, after years of no releases.
  1. charcircuit · 1789719808 · focus · HN ↗
    Development was never stopped for jemalloc. This is a common misconception. There just were not releases being tagged and packaged against the ongoing development.
2. ck45 · 1789711499 · focus · HN ↗
  I just checked whether it's the first release after Jason Evans stepped down as maintainer, but it isn't. That was the previous release, 5.3.1
3. defrost · 1789711510 · focus · HN ↗
  The noted resumption and likely a small amount of halo effect from the Comparison of Malloc() Algorithms thread two / three days ago.
  - <a href="https://news.ycombinator.com/item?id=49715318">https://news.ycombinator.com/item?id=49715318
4. baq · 1789714858 · focus · HN ↗
  jemalloc is something you should be aware of if you do software for a living
  1. rfgplk · 1789715005 · focus · HN ↗
    Why? Writing a memory allocator is quite simple, and I'd argue that _everyone_ should write one from scratch for any kind of high performance application. It's also trivial to outperform general purpose allocators that have to satisfy countless constraints. I've written numerous special purpose mallocs that are a) both provably (formally) safer than the standard armada and b) significantly faster (>10x throughput).
    groomlake · 1789715347 · focus · HN ↗
    Your experience writing memory allocators is irrelevant. The point is that jemalloc is widely used and that’s why it makes sense to be aware of it.
    HackerThemAll · 1789715717 · focus · HN ↗
    I'd happily see performance, latency and stability of your allocators in massively multithreaded, long-living programs with workloads where hundreds or thousands of parallel threads continuously create and destroy short-lived small and medium objects.
    Writing allocators for domain-specific access patterns is easy. Writing a general-purpose high performing, stable allocator with bounded P99 latency is hard.
    Give your friend, Dunning–Kruger, some better pills to keep him from speaking through you.
    Pannoniae · 1789716885 · focus · HN ↗
    You're correct, but his point is that you don't need to solve the generic problem. Solving the generic problem is very hard. Grug doesn't like solving hard problem. What does grug do? Solve five easy problems. Make an arena for the short-lived objects, reuse the objects, use generic multithreaded malloc for the rest. Grug happy.
    matheusmoreira · 1789718673 · focus · HN ↗
    Not everything needs to be general purpose. Allocation can be as easy as bumping a pointer, and it's hard to beat that.
    cv5005 · 1789725486 · focus · HN ↗
    >where hundreds or thousands of parallel threads continuously create and destroy short-lived small and medium objects.
    Should one even want a global, general purpose heap allocator for that? Seems like a crazy idea to even consider.
    Mikhail_Edoshin · 1789726580 · focus · HN ↗
    I guesd the point was that before you consider using a different allocator you should rule out a custom one.
    And that's rather hard, because a general purpose allocator makes all decisions based only on the requested size. This is a very simple interface and such a tool is worth having. But a custom allocator can both bake in a specific scenario and provide more nuanced interaction.
    jonkerz · 1789726839 · focus · HN ↗
    >massively multithreaded, long-living programs with workloads where hundreds or thousands of parallel threads continuously create and destroy short-lived small and medium objects.
    My first thought would be to use per thread pool allocators.
    stackghost · 1789716567 · focus · HN ↗
    Writing an allocator is simple, you’re correct, but writing an allocator that doesn’t suck is not simple.
  2. stackghost · 1789716792 · focus · HN ↗
    In the Before Times, the vast majority of software was written in garbage collected language where a working knowledge of the relative merits of C memory allocators is not useful or particularly relevant.
    Why would the scads of people writing JavaScript, Java, python, go, rails, etc need to be aware of jemalloc?
    iam-da-author · 1789718459 · focus · HN ↗
    TL;DR: Because the runtime of most GC:d languages uses malloc for its internal data structures.
    I work for the runtime team of JPG @ Oracle. We use malloc in Hotspot, quite a lot actually! Providing your JVM with a good malloc can improve the performance of the runtime, both in terms of CPU and memory, by quite a bit.
    I don't think you need the details, but it's good to be aware that some mallocs are better than others, and there are multiple of them. Being aware of jemalloc is a good way of being aware of the facts I just mentioned :-).
    stackghost · 1789747562 · focus · HN ↗
    The vast majority of professional developers are not in a position where they can just swap out allocators willy-nilly. They take what they get, and write the code they're assigned to write on the platform the CTO or their product lead or whoever has decided upon.
    iam-da-author · 1789748146 · focus · HN ↗
    Okay, well, I guess all I can say is that if you strive to be one of the developers who do get the chance to care about this stuff, then you should know this stuff :-).
    xxs · 1789720488 · focus · HN ↗
    >...the vast majority of software was written in garbage collected language
    and even then recently it costed (us) quite a few months to blame JVM and later the default glibc memory allocator for running out native (not java heap memory) - had to exclude all possible native libs (zlib, zstd via jna), direct buffers, sockets, thread stacks and so on. Changing the malloc to jemalloc solved the issue, even though initially it was done for its debugging capabilities.
    It's just a great memory allocator.
    fc417fc802 · 1789723818 · focus · HN ↗
    I'm never sure if I should be upset or happy when I've been debugging a problem for long enough that I finally decide to switch something out in order to improve visibility and that immediately solves the problem for entirely unexpected reasons. Particularly all the times when I couldn't readily discern why.
    javier2 · 1789762429 · focus · HN ↗
    We changed to jemalloc first on a jvm service which we could never get to run in its kube memory limit. with jemalloc its been dead stable for years, and we made it the default for all jvm services
    nh2 · 1789721669 · focus · HN ↗
    Memory allocation behaviour has visible impact also for users of managed languages, and the behaviour of software for end users.
    In our Python program, a bit of numpy processing of large pictures led to 100 GB not being returned to the OS by glibc's default allocator and the machine running out of memory shortly after. With jemalloc's reliable memory return settings, those problems disappear.
    majora2007 · 1789732884 · focus · HN ↗
    I'm in the same boat, I just switched to using it for Kavita, which only does some basic open Image -> Thumbnail to smaller size -> write to disk when importing new comics/books and on linux, memory could swell to 10GB and never get released. Switched to jemalloc and instantly memory stayed well below 1GB.
    nh2 · 1789738642 · focus · HN ↗
    Generally yes, but the wording of "instantly" begs for the following pedantic remark:
    This is controlled by jemalloc settings `dirty_decay_ms`, `muzzy_decay_ms`, and their interaction with `background_thread`.
    `dirty_decay_ms` currently defaults to 10 seconds, so it's not that instant.
    That is important e.g. for single-threaded programs that start other programs, such as my Python example: If it starts a subprocess before the 10 seconds elapse after `free()`, Python (and jemalloc) do not run, and get no chance to return memory to the OS.
    In such cases, either enable `background_thread`, or set the `_decay_` values to `0` to ensure immediate return to the OS upon `free()`. (This costs some performance.)
    See e.g. <a href="https://github.com/jemalloc/jemalloc/issues/2688" rel="nofollow">https://github.com/jemalloc/jemalloc/issues/2688
    stackghost · 1789742590 · focus · HN ↗
    Okay but do you think the hordes of JavaScript developers at FANG can just change the browser’s allocator?
    The number of programmers who are in positions to care about jemalloc vs other malloc is minuscule
    yxhuvud · 1789731094 · focus · HN ↗
    Because unfortunately, the runtimes belonging to all or at least most of those languages perform a lot better with jemalloc than with the system default.
    I wish that wasn't the case, but it is.
5. imhoguy · 1789717806 · focus · HN ↗
  I upvoted it because I benefit from jemalloc in my stack (RoR) and I am tired of AI taking over HN front page. Let the hacker spirit be back!
  1. adityapatadia · 1789720472 · focus · HN ↗
    Upvoted for the same reason. We would not be able to run our workloads without Jemalloc. Kudos to this awesome piece of software.
  2. smartmic · 1789721171 · focus · HN ↗
    You are not alone - my first thought was 'oh, HN is trying to bring back the disappointed hackers'. All this AI hype over every little model update fart is so exhausting and boring …
6. gjvc · 1789721299 · focus · HN ↗
  because people like you are too busy whining about it to put up something more interesting
7. kreco · 1789722418 · focus · HN ↗
  > Why is this on the HN front page?
  This question was not necessary. You know the answer, because people upvoted this.
vocx2tx · 1789711903 · focus · HN ↗
For some context on why this release is notable: Jemalloc Postmortem [0]
[0] <a href="https://news.ycombinator.com/item?id=44264958">https://news.ycombinator.com/item?id=44264958
1. ezst · 1789728228 · focus · HN ↗
  > I don’t want to dwell on drama, but it is perhaps worth mentioning that we reached a sad end for jemalloc in the hands of Facebook/Meta even though most of the people involved were acting in good faith.
  Far from the only case. Trillion dollar companies having sudden interest in your open source project is not necessarily a long term benefit.
  1. titanomachy · 1789763401 · focus · HN ↗
    I thought it was developed internally there
    beanjuiceII · 1789764414 · focus · HN ↗
    but then we can't make it all about ripping on big companies
2. eatonphil · 1789731586 · focus · HN ↗
  And some additional context from a few months ago, building off the postmortem.
  <a href="https://theconsensus.dev/p/2026/04/16/who-even-uses-jemalloc-anyway.html" rel="nofollow">https://theconsensus.dev/p/2026/04/16/who-even-uses-jemalloc...
  1. nextaccountic · 1789742274 · focus · HN ↗
    Also, 7 months ago, <a href="https://github.com/facebook/jemalloc" rel="nofollow">https://github.com/facebook/jemalloc said
    > Development of Jemalloc will transition back to the original open source project: <a href="https://github.com/jemalloc/jemalloc" rel="nofollow">https://github.com/jemalloc/jemalloc. Meta’s fork of the Jemalloc project will be fully archived as part of the transition. We look forward to continuing the collaboration with the community to drive jemalloc.
    > See blog post for details: <a href="https://engineering.fb.com/2026/03/02/data-infrastructure/investing-in-infrastructure-metas-renewed-commitment-to-jemalloc/" rel="nofollow">https://engineering.fb.com/2026/03/02/data-infrastructure/in...
3. pstoll · 1789749341 · focus · HN ↗
  Post-ZIRP reality of corporate self-interest being re-established.
lordnacho · 1789717416 · focus · HN ↗
I always wondered, is it French? "Je m'alloc du memory"
1. sam_lowry_ · 1789718267 · focus · HN ↗
  Rather a tradition to call a malloc by the initials of the implementer: Jason Evans malloc (jemalloc), Poul-Henning Kamp malloc (phkmalloc), Doug Lea (dlmalloc).
  P.S. I also wondered whether systemd had any cultural reference to Système D aka Système Débrouillard, but Pottering does not seem to engage in word play on other occasions, so probably not.
  1. tefkah · 1789720226 · focus · HN ↗
    damn i always thought it was a french thing, this is blowing my mind
    eliaspro · 1789722061 · focus · HN ↗
    "Yes, it is written systemd, not system D or System D, or even SystemD. And it isn't system d either. Why? Because it's a system daemon, and under Unix/Linux those are in lower case, and get suffixed with a lower case d."
    Source: <a href="https://brand.systemd.io/" rel="nofollow">https://brand.systemd.io/
    NewJazz · 1789763852 · focus · HN ↗
    [delayed]
    fizzbuzzbarbazz · 1789737975 · focus · HN ↗
    you were right, check siblings of your comment.
  2. justincormack · 1789726951 · focus · HN ↗
    It does
    > Systemd was launched in April 2010; it adopts various ideas from previous init systems and combines them with a uniform configuration and administration interface. Systemd operates as a background service (daemon) and controls important system configuration tasks including hardware initialisation and the starting of server processes. The developers thought that its name is suitably reminiscent of the French term "système D", an expression that relates to "thinking on your feet" and describes high-speed technical problem-solving abilities such as those displayed by TV action hero MacGyver.
    <a href="https://web.archive.org/web/20121014173559/http://www.h-online.com/open/features/Control-Centre-The-systemd-Linux-init-system-1565543.html" rel="nofollow">https://web.archive.org/web/20121014173559/http://www.h-onli...
2. simonask · 1789719053 · focus · HN ↗
  Thanks, now my brain will forever read it like that. I'm not even a little bit French.
3. u8080 · 1789722452 · focus · HN ↗
  Memory je Srbia
4. jibcage · 1789723775 · focus · HN ↗
  Fun grammatical fact that I only learned after years of speaking French: when borrowing words from other languages, you usually (not always) take the gender of the equivalent word in French, so technically it would be “de la memory” :)
  1. thrance · 1789724830 · focus · HN ↗
    That's the rule the old geezers at the Academy insist on. But then you have idiotic situations where everyone is using "le" for e.g. the COVID virus, while Academicians cry about the D meaning "Disease", which is feminine, making it "la COVID" in their book. As for all languages, the most important rule is that usage prevails. And that's something we in France still have a hard time integrating into public discourse.
    progval · 1789726817 · focus · HN ↗
    An interesting case is "WiFi", short for "wireless fidelity". "Fidélité sans fil" in French should be feminine, but every technical person says "le WiFi" (masculine) while many (most?) non-technical people intuitively say "la WiFi" (feminine).
    ButlerianJihad · 1789726942 · focus · HN ↗
    If you keep your access point secure and in good working order, make sure to publicly credit your excellent "Wi-fu"
    hobo123 · 1789727579 · focus · HN ↗
    Better keep the wifi working, or your waifu could get angry.
    wpollock · 1789752057 · focus · HN ↗
    WiFi is not an acronym for "wireless fidelity"; the developers likely just thought it sounded cool. The term is probably just a play on the words from the audio term "high fidelity". The phrase "Wireless Fidelity" is meaningless.
    The more you know!
    echoangle · 1789770841 · focus · HN ↗
    Wiki on wifi:
    > It is disputed whether the name Wi-Fi is short-form for 'Wireless Fidelity',[34] although the Wi-Fi Alliance did use the advertising slogan "The Standard for Wireless Fidelity" for a short time after the brand name was created,[31][35] referenced "the Wi-Fi (Wireless Fidelity) logo" in a white paper[33] and the Wi-Fi Alliance was also called the "Wireless Fidelity Alliance Inc." in some publications.[36] IEEE, a separate but related organization, has stated "WiFi is a short name for Wireless Fidelity" on their website.[37][38] The name Wi-Fi was partly chosen because it sounds similar to Hi-Fi, which consumers take to mean high fidelity or high quality. Interbrand hoped consumers would find the name catchy, and that they would assume this wireless protocol has high fidelity because of its name.[39]
    So it’s not really safe to say it’s not meant to mean wireless fidelity, in fact it sounds pretty likely.
5. throw0101a · 1789729799 · focus · HN ↗
  > "Je m'alloc du memory"
  Jason Evans, JEmalloc:
  * <a href="https://jasone.github.io/2025/06/12/jemalloc-postmortem/" rel="nofollow">https://jasone.github.io/2025/06/12/jemalloc-postmortem/
ksec · 1789718758 · focus · HN ↗
Ok. Why both the homepage and its Github repo doesn't make a single mention of Jason Evans? I know he stepped down but surely it is at least worst mentioning it?
Is Meta still using it and developing it? If not who are the driving force behind it now? I just checked there wasn't a release since 2022 and then we have this now. Something changed?
Just wish we have a little bit of context. But it is also great it is continue being maintained. It makes a huge difference for Ruby on Rails Apps.
1. aktenlage · 1789719380 · focus · HN ↗
  > Just wish we have a little bit of context
  See the comment of vocx2tx
  1. throw0101a · 1789729977 · focus · HN ↗
    > See the comment of vocx2tx
    <a href="https://news.ycombinator.com/item?id=49750698">https://news.ycombinator.com/item?id=49750698
    To:
    * <a href="https://news.ycombinator.com/item?id=44264958">https://news.ycombinator.com/item?id=44264958
    * <a href="https://jasone.github.io/2025/06/12/jemalloc-postmortem/" rel="nofollow">https://jasone.github.io/2025/06/12/jemalloc-postmortem/
2. feldrim · 1789720803 · focus · HN ↗
  It's only mentioned in history: <a href="https://github.com/jemalloc/jemalloc/wiki/Background#history" rel="nofollow">https://github.com/jemalloc/jemalloc/wiki/Background#history
3. loeg · 1789760170 · focus · HN ↗
  It's got "JE" in the name.
skavi · 1789720662 · focus · HN ↗
does anyone familiar with the art have thoughts on why only tcmalloc switched from thread caches to cpu caches? would it make linux behavior diverge too much from other platforms?
1. enduku · 1789722205 · focus · HN ↗
  I think tcmalloc gains on thread churn and oversubscription by going the cpu-cache route on Linux. on other platforms, I am not so sure but that can be offset by say a treiber-stack like setup for cross-thread frees/teardowns. So lesser code for Linux for similar fastpath design I guess.
  1. jeffbee · 1789746157 · focus · HN ↗
    > on other platforms, I am not so sure
    tcmalloc only works on Linux.
2. rwmj · 1789722417 · focus · HN ↗
  (Not an expert but ...) unless you pin threads to cores, which is not the default and somewhat awkward in Linux for user applications, having a per-thread cache doesn't really make sense as your thread could be moved to another core and then your cache will no longer be local to the physical cache.
  1. skavi · 1789728355 · focus · HN ↗
    i think we agree that per cpu cache seems superior. i’m looking for the other side of this. most allocators seem to have stuck with per thread.
    Someone · 1789731422 · focus · HN ↗
    [delayed]
    skavi · 1789732194 · focus · HN ↗
    <a href="https://google.github.io/tcmalloc/rseq.html" rel="nofollow">https://google.github.io/tcmalloc/rseq.html
    i don’t believe rseq based cpu local caches require memory barriers on the fast path.
    fc417fc802 · 1789734977 · focus · HN ↗
    Setting aside whether or not you can pull off a lock free approach here we can be certain of a couple things. There will be at least some overhead that must be paid somewhere even if that's on a separate management thread. And there will be a lot of additional complexity because that's just how concurrency always is.
    Meanwhile the better the scheduler performs the more competitive the thread local approach becomes.
    skavi · 1789751542 · focus · HN ↗
    <a href="https://docs.kernel.org/userspace-api/rseq.html" rel="nofollow">https://docs.kernel.org/userspace-api/rseq.html
    cost for interruption in an rseq critical section is that the PC gets overwritten to the rseq abort entry point before the task is rescheduled. no management thread necessary.
    should be fairly minimal cost, especially assuming interruptions in the critical section are rare.
    fc417fc802 · 1789771803 · focus · HN ↗
    That's certainly interesting but I don't see how it would change my answer to you. Your question was why projects don't switch. My answer was because doing so seems likely to be a wash at absolute best.
    Giving it some more thought, I expect caches will typically be wiped out by a context switch. So the only place rseq is likely to benefit an allocator is on systems with multiple NUMA nodes where you'd like to make sure any management code isn't paying a penalty by hitting the wrong address range.
    IIUC the primary thing rseq (and CPU local data) is good for is obviating the need for atomics (specifically the resultant cache line ping-pong) but thread local data already accomplishes that.
    skavi · 1789782462 · focus · HN ↗
    > seems likely to be a wash at absolute best
    maybe we weigh things differently, because:
    > massive oversubscription of physical CPU cores (ie tens of thousands of threads) where TLS becomes utterly wasteful while also thrashing the cache
    seems worth solving to me
    fc417fc802 · 1789786267 · focus · HN ↗
    Are you sure you don't just have an axe to grind? Because that is an exceedingly uncommon edge case. Typically you only have a few threads and you aren't inundating the allocator with requests thus it is unlikely to make any practical difference.
    Outside of that, TLS has zero overhead and doesn't suffer from contention while rseq involves a small dance and carries a penalty if preempted. I'm certainly open to benchmarks but to me it very much looks like a mixed bag that only comes up when you're already in questionable territory to begin with. If it does come up I'd guess that a handful of threads with contention is a much more common scenario than thousands of threads per physical core and only minimal preemption.
    I also expect something like a web server servicing thousands of requests in parallel to use an event loop instead of spawning an equivalent number of threads. I'm struggling to come up with a scenario where you haven't already fatally shot yourself in the foot and this remains a useful optimization to make. It's certainly relevant if you're using fibers (green threads, whatever you want to call them) but at that point you aren't in c calling malloc and your language runtime will (one hopes) already be taking care of all this for you.
    skavi · 1789794912 · focus · HN ↗
    > Are you sure you don't just have an axe to grind? Because that is an exceedingly uncommon edge case. Typically you only have a few threads and you aren't inundating the allocator with requests thus it is unlikely to make any practical difference.
    Totally fair, and I agree that this is what you should do. But I’m only grinding this axe because I’ve personally had to deal with a system that went against most of that guidance.
    We ran far too many threads in a memory-constrained environment. Thread count was many multiples of core count. And we weren’t even doing too much worse than a typical Rust tokio application (where all fs ops are dispatched to a thread pool of effectively unbounded size).
    So I totally agree that this is “questionable territory”, but honestly, any application that’s outgrown the basic glibc malloc has made a few mistakes.
    Someone · 1789740958 · focus · HN ↗
    [delayed]
    Veserv · 1789747746 · focus · HN ↗
    That is because you do not need to clear the field at the end of a critical section. It contains the contiguous instruction range where it fires so there is no problem with leaving it active forever unless you have another critical section where you want to use it.
    No explicit memory barrier is required anywhere as the value is only read in supervisor mode and a privilege switch implicitly issues a LS-LS barrier on all major architectures.
    Someone · 1789762420 · focus · HN ↗
    [delayed]
    ckennelly · 1789777937 · focus · HN ↗
    TCMalloc has different abort handlers for each function: If preempted, we need to know where to restart.
    If `rseq_cs` is no longer describing a relevant address, that is, the program counter has moved past it, the kernel just ignores it.
    fweimer · 1789753155 · focus · HN ↗
    It's just a compiler barrier (signal fence), not a memory barrier that concerns the CPU. The CPU is free to reorder loads and stores.
    ckennelly · 1789777570 · focus · HN ↗
    TCMalloc TL here :)
    The code is executed by a single thread. Everything retires in program order. There is no need for a memory barrier between starting the critical section and its body.
  2. jeffbee · 1789746080 · focus · HN ↗
    Exactly. You want memory arenas that are hot in this CPU's caches. If your thread moves, its per-thread caches are now elsewhere. Original TCMalloc was developed in the days of 2-4 core servers. Current TCMalloc was an evolution in the context of 32+ core servers.
    skavi · 1789752521 · focus · HN ↗
    my feeling is that the space efficiency gains are probably more significant than the reduction in core migration costs. many applications have far more threads than the system has cores.
    jeffbee · 1789752659 · focus · HN ↗
    Sure, also true that the per-CPU scheme co-evolved with the proliferation of services with thread-per-request architectures having way more TIDs than cores.
  3. loeg · 1789760015 · focus · HN ↗
    Don't you just take the current cpuid when you go to access the cache again? Then you mutex and access the per-cpu state. There is a tiny race window but 99.99% of the time you will be hitting the same cpu's cache as you just identified, and there will be ~zero contention.
    The main issue is thread preemption while you're holding a per-core cache mutex. Some other thread can't do meaningful work using the cache while the holder is sleeping.
    ckennelly · 1789778188 · focus · HN ↗
    With restartable sequences in Linux, there is no need for mutexes or RMW atomics. The mutual exclusion is guaranteed by the kernel.
    loeg · 1789792535 · focus · HN ↗
    Fair enough.
albertgoeswoof · 1789724361 · focus · HN ↗
I switched to jemalloc on a sidekiq queue and memory dropped from 8gib to under 1gib
There’s a slow memory leak somewhere in my code but with jemalloc it no longer actually matters.
Thanks to jemalloc team for this!
1. nvartolomei · 1789734786 · focus · HN ↗
  <a href="https://devblogs.microsoft.com/oldnewthing/20180228-00/?p=98125" rel="nofollow">https://devblogs.microsoft.com/oldnewthing/20180228-00/?p=98...
  1. paper2d · 1789744317 · focus · HN ↗
    This is the most funny thing I read today!
    cduzz · 1789751116 · focus · HN ↗
    Fun bugs in missiles are sometimes unfun.
    <a href="https://www-users.cse.umn.edu/~arnold/disasters/patriot.html" rel="nofollow">https://www-users.cse.umn.edu/~arnold/disasters/patriot.html
  2. albertgoeswoof · 1789762165 · focus · HN ↗
    Ha, it’s like that for us except we deploy an update at least every few months, which obliterates our machine and restarts then launch sequence
throw0101a · 1789729699 · focus · HN ↗
Related, from three days ago, "Comparison of Malloc() Algorithms":
* <a href="https://news.ycombinator.com/item?id=49715318">https://news.ycombinator.com/item?id=49715318
atombender · 1789744945 · focus · HN ↗
I use Jemalloc on a project because it has per-thread allocation counters. This lets me not only track what each thread is using, but also restrict workloads by enforcing a memory budget. Since my application is almost completely CPU-bound, I allocate one thread per core and then have some smart scheduling to route requests to the threads. I looked at tcmalloc and mimalloc, and neither had this feature at the time, nor did they seem to have any similar feature that could let me have per-thread heaps, which surprised me.
ggg011012 · 1789748150 · focus · HN ↗
Nice to see jemalloc active again. The long-term health of the upstream project is probably just as important as the allocator improvements themselves.
collimarco · 1789756983 · focus · HN ↗
Jemalloc is great for Ruby on Rails apps, and drastically reduces memory usage for the same workloads. We use it for all our Ruby / Rails apps running on Kubernetes / Cuber: <a href="https://answers.abstractbrain.com/how-to-enable-jemalloc-for-ruby-docker-image" rel="nofollow">https://answers.abstractbrain.com/how-to-enable-jemalloc-for...

Open on Hacker News to reply ↗

Unofficial Hacker News client; not affiliated with Y Combinator.