eklitzke

12 ms·

121.
by eklitzke 3y ago
Alternatively, you're 50% productive everywhere.
122.
by eklitzke 3y ago
Do you have experience doing this in C/C++? There are a bunch of things about the language models for both (e.g. how symbol visibility and linkage work) that make doing DI in C/C++ significantly harder than in most other languages
123.
by eklitzke 3y ago
They likely do use mapbox for rendering maps, as their SDK is really customizable, is designed to work with the OSM data format, and you don't need to pay mapbox to use it (at least for older versions). But mapbox is not necessarily a
124.
by eklitzke 3y ago
It doesn't really make sense to have an API to tell if reading from a file would block or not because page cache data can be evicted at any time. Even if there was an API that could tell you your next read would be non-blocking, there
125.
by eklitzke 3y ago
For small enough tables doing a full scan will be faster than an index. This is also true for regular non-database applications like checking if an item is present in a small collection: it's faster to do a linear scan over a small vec
126.
by eklitzke 3y ago
LTO basically just calls back into the compiler and is multi-threaded on lld and mold at least, and probably anything else that supports LTO. And make sure you're using ThinLTO, it's still expensive but much faster than full LTO
127.
by eklitzke 3y ago
This paper is ~15 years old. It was published in 2009, but the data was collected 2006-2008. As densities for things like RAM increase, error rates have to decrease commensurately to hide errors from end users. Additionally, Google runs har
128.
by eklitzke 3y ago
I'm not sure if your claim here is correct. The patch is to change call sites like priv->set->use++; To look like: nf_tables_activate_set(ctx, priv->set); Where this function is defined as: void nf_tables_act
129.
by eklitzke 3y ago
The patch doesn't fix anything with pointer arithmetic: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin...
130.
by eklitzke 3y ago
>Using compilers for highlighting basically doesn't happen because they are too slow. This is not completely accurate, as clangd does support this: https://github.com/llvm/llvm-project/blob/main/c
131.
by eklitzke 3y ago
Every C and C++ compiler has supported inline asm for decades, so that's what you should use if you really need to control the assembly output. The fact that you can switch between the two within the same function is one of the selling
132.
by eklitzke 3y ago
I commented on this elsewhere as well, but nowadays you should reach first for AutoFDO rather than PGO.
133.
by eklitzke 3y ago
Right, this is why you should use AutoFDO nowadays not PGO. With AutoFDO you occasionally (e.g. in prod this might be something like record for 1s on average every 300s) record what branches were taken using perf-record from prod binaries,
134.
by eklitzke 3y ago
I haven't tested this either, but why would the branch be "largely unpredictable"? It's always going to evaluate to false except once, and the one time it evaluates to true the rest of the search will be finished within
135.
by eklitzke 3y ago
>This is true if your end goal is to have a super fast program but that is very rarely the case. This is true in some banal sense, but kind of misses the point that there are certain domains where high performance software is a given, an
136.
by eklitzke 3y ago
Linux does not have a flat linking namespace (for example, see RTLD_NEXT in the dlsym man page). If it did, this wouldn't be a problem because everything would use the libc malloc or everything would use the tcmalloc implementation. It
137.
by eklitzke 3y ago
As someone who has done performance work for most of my career, I strongly agree with what you've written here. If you have a program that isn't well optimized, it might be true that once you start profiling you can find some hot
138.
by eklitzke 3y ago
The update at the bottom of the article points out that new Chromebooks (released since 2020) are supported for 8 years, which is pretty close to the 10 years requested, and longer than most other devices.
139.
Mercurial Implementation in Rust(fossies.org)
1 points by eklitzke 4y ago|0 comments
140.
by eklitzke 4y ago
I'm very skeptical that this actually makes things faster. For one, zstd is definitely going to be CPU bound rather than I/O bound. But even if it wasn't, there shouldn't be a performance benefit to reading a file sequen
141.
by eklitzke 4y ago
Hard coding behavior like for the STL that seems pretty questionable, especially given that std::map and std::unordered_map have poor performance compared to other alternatives (e.g. absl::btree_map and absl::flat_hash_map, and likewise fol
142.
by eklitzke 4y ago
Because otherwise the evaluation order of the following construct is undefined, and you can get different results if you compile your code with different compilers: foo()[bar()]; In nearly all cases it won't matter, but it can m
143.
by eklitzke 4y ago
For the point about the Google firmware modules, the firmware directory you linked to is specifically for Chromebooks, which people do have, and the modules are useful if you want to run vanilla Linux with coreboot on this hardware. If the
144.
100 Prisoners Problem(en.wikipedia.org)
1 points by eklitzke 4y ago|0 comments
145.
by eklitzke 4y ago
This is a common technique in transposition ciphers, which are one of the oldest ciphers used since at least ancient Greek times.
146.
by eklitzke 4y ago
You can obviously build an RPC protocol on top of TCP, people have been doing it for decades. However there are things that are difficult to efficiently implement on top of TCP (multiplexing different logical streams over the same connectio
147.
by eklitzke 4y ago
This example isn't doing pointer arithmetic.
148.
by eklitzke 4y ago
This is not UB. In this case where you're using the wrong pointer type the worst thing that can happen is you can have aliasing issues. For example, if I have an int* and a double*, the C compiler is free to assume that the pointers ca
149.
by eklitzke 4y ago
This particular routine doesn't seem that useful, but sometimes these weird vector algorithms that don't seem useful on their own are composed together in interesting ways to solve a larger, more interesting problem. For example,
150.
by eklitzke 4y ago
I don't think it is necessarily a "problem" that it can't be perf-farmed anymore though. Google groups isn't perfect but it does a lot of things well (the bugs mentioned in TFA not withstanding), is used extensively

More ›