rust VS mimalloc

nightly: Necessary because of the RTN feature.

This Sunday, I had a bit of extra time, so I decided to brush up on Rust. Whether you are a seasoned developer or just starting out, getting your tools set up is always the first step.

There was an idea floated for another lint `#[diagnostics::lint_as_temporary(reason = "...")]`, which is supposed to be added by implementors of such locks. https://github.com/rust-lang/rust/issues/131154#issuecomment...

It has excellent documentation on how to get started at the official site.

So I did a catalyst build of EX a while back (which is where https://github.com/rust-lang/rust/issues/106021 came from) - but rather anticlimactically the end result looked almost identical to the normal iOS app when running under macOS; I don't remember the sidebar/toolbar looking particularly better, and that was my main reason for doing the build in the first place (to get a flexibly resizable left toolbar). The main advantage seemed to be that it would run on Intel.

If things have improved I'd love to know, and then perhaps we'll have another shot at it. Are there any good comparison screenshots of the two approaches (with a toy app, i guess) anywhere?

I think you're being overly optimistic in assuming that is actually the case. Bugs like https://bugs.llvm.org/show_bug.cgi?id=39282 make me think that even simple examples like you wrote could have had problems. Here's a similar bug but for GCC: https://github.com/rust-lang/rust/issues/54878#issuecomment-...

I'm sure there were probably others.

It's generally true that C/C++ code rarely if ever uses restrict & that Rust was the first to actually put any real pressure on those code paths and once it was found it took over a year to fix and it's incorrect to state that the miscompilation was only in code patterns that would only exist in Rust.

Deno (/ˈdiːnoʊ/, pronounced dee-no) is a JavaScript, TypeScript, and WebAssembly runtime with secure defaults and a great developer experience. It's built on V8 Rust, and Tokio.

Rust Programming Language

Worked on a relevant project for Meta.

There’s a lot of overhead as soon as you involve a filesystem rather than a block device, even on a dedicated disk, particularly with btrfs. I don’t know if the same is true with MacOS and APFS; this isn’t the area I usually work in. However copy-on-write file systems (which I believe apfs is) are somewhat predisposed to fragment files as part of the dedup process; I don’t know if apfs runs it online in some way so it could have affected the article’s author’s results.

The standard library implementation details can also have a huge impact, eg I observed with Rust for a prior project when I started fiddling with the read buffer size:

https://github.com/rust-lang/rust/issues/49921

The other issue that I see is that their I/O is implicitly synchronous and requires a memory copy. They might see better performance if they can memmap the file, which can probably solve both issues. Then if C# allows it, they can just parse the CSV in-place; with a language like Rust, you can even trivially do this in a zero-copy manner, though I suspect it’s more involved with C# since this requires setting up strings / parsing that point at the memmaped file.

At that point, the OS should be theoretically able to serve up the cached file for the application to do some logic with, without ever needing to copy the full contents again into separate strings.

Switching to jemalloc or mimalloc doesn't improve the performance either.

mimalloc: mimalloc is an open source implementation of malloc, currently the best performing allocator.

Some compiler writers thought that was the case, if [0] is related to OP. I don't have a "modern" (after 6th gen) Intel CPU to test it on, but note that most programs are compiled for a relatively generic CPU.

[0]: https://github.com/microsoft/mimalloc/issues/807

Yes, it's very efficient and that's not where the main problem lies. However, small allocations with modern C heap allocators like mimalloc or snmalloc has gotten extremely efficient as well. Would be interesting to see a benchmark comparison with Java's G1 and ZGC.

Memory management for C is not itself a solved problem, not only is there a lot of performance to squeeze out of malloc itself (the benchmarks on https://github.com/microsoft/mimalloc exemplifies the variance between the implementations), but it's up to the programmer to implement memory management in the large in an efficient way, which is not an easy task. One sure mark of a slow C program is one with a ton of mallocs and frees strewn all over.

It's a very terse howto for replacing Factorio's memory allocator with Microsoft's mimalloc, and configuring mimalloc so that memory is always allocated on huge pages by using madvise().

I was wondering if Koka's perceus referencing counting style is any different from the reference counting that Lean4 implements? I understand that both rely upon the mimalloc (https://github.com/microsoft/mimalloc) library in the backend.

If you are fine with heap allocations then there are only few dozens operator new/delete to override to regain control over normal C++ code memory use. Allocators and STL all need to call those. At least that's what gaming does on all platforms. If you need examples you can check Mimalloc on github ( https://github.com/microsoft/mimalloc/blob/master/include/mimalloc-new-delete.h ).

What's the difference between this and Microsoft's? https://github.com/microsoft/mimalloc