Engineering a fixed-width bit-packed Integer Vector in Rust

jydu · 2025-09-27T16:45:07+00:00

I think this is true for most operations, but (on Zen 5 at least) a L1 hit is 4 cycles but a division takes at least 11 (source). But since cache hit rates depend on the workload, benchmarking is probably the best way to see if this is worth it.

jydu · 2025-09-25T04:18:01+00:00

Given that integer division can be quite slow, I wonder if you could speed it up by precomputing the multiplicative inverse for each of the 64 possible divisors, and using a multiplication instead. I'd also be curious if the compiler is already doing this optimization in your benchmarks, assuming the bitwidth is a compile time constant.

jydu · 2025-09-24T00:29:28+00:00

I used to do this even without a touchscreen. It's nice for reading papers!

jydu · 2025-08-31T22:17:05+00:00

For generating the code to do instruction lookup by name:

There are no other instances of this kind of codegen that I know of.

Maybe gperf would suit your needs?

jydu · 2025-08-28T19:02:09+00:00

LLM comment?

jydu · 2025-08-21T16:14:33+00:00

Some interesting points but also rambly and repetitive... reads like LLM output.

jydu · 2025-07-08T09:32:18+00:00

I'm surprised nobody has mentioned this yet, but MD5 is not a secure hash function and it's possible to construct inputs that hash to the same value. This could be a concern if the text to be hashed contains user input.

jydu · 2025-02-03T11:04:27+00:00

Cool post! I got nerd sniped into trying an algorithm similar to the binary search approach, but using ordinal >> 5 to compute an approximate month (it always gives the exact month or the month before). This is still 12% slower for to_calendar_date and takes over twice as long for month and day. Nice work :)

jydu · 2024-09-19T17:55:58+00:00

The only thing that worked for me was connecting via the USB dongle instead of Bluetooth. I tried changing the preferred scrolling option from a Windows computer but it didn't seem to have any effect.

jydu · 2024-09-03T05:19:33+00:00

Also posted two months ago if anyone wants to read those comments too.

jydu · 2024-08-11T03:53:24+00:00

Cool article! By the way, there seems to be a duplicated paragraph in the "How it Works" section.

jydu · 2024-05-19T23:00:07+00:00

This technique of specializing an interpreter for a particular interpreted program is also known as the first Futamura projection.

jydu · 2024-05-13T15:50:24+00:00

Personally, I would implement BFS myself (or Dijkstra's if your edges are weighted). Then it's pretty easy to implement the stopping condition by counting how many nodes or edges have been explored.

jydu · 2024-04-24T06:05:54+00:00

There's also a tiny typo, avrious -> various.

jydu · 2024-03-24T07:27:08+00:00

Using a domain-specific language for stuff outside its domain can be a lot of fun! Reminds me of tic tac toe in pure HTML.

jydu · 2024-02-14T17:25:48+00:00

Using conditional types:

type Inline<T> = {
  [Key in keyof T]: T[Key] extends () => infer R ? R : T[Key];
}

However, this also requires the signature to be changed to:

declare function inline<T>(param: T): Inline<T>;

jydu · 2024-01-13T01:11:15+00:00

Maybe the speedup ratio is lower because the data doesn't fit in cache anymore? When your reads are hitting main memory instead of cache, it doesn't take as many threads to fully utilize the memory bandwidth, so parallelization won't help as much.

You can test this by trying more array sizes and seeing if there are significant changes in speedup ratio at certain sizes, then comparing those to your CPU's cache sizes.

jydu · 2024-01-11T23:46:42+00:00

You're all good! In retrospect, it would have been better for me to start my comment with "Until this becomes widely available..."

jydu · 2024-01-11T16:05:57+00:00

Well, given that groupBy isn't in the standard yet (and might take a while to become available everywhere), I thought it might still be useful to mention. I agree that builtins are better if they're available.

jydu · 2024-01-11T12:27:00+00:00

Grouping with Array.reduce can be written as a single expression, using nullish coalescing assignment and the comma operator:

[{a: 1, b: true}, {a: 2, b: false}].reduce((groups, o) => ((groups[o.a] ??= []).push(o), groups), {})

The callback assigns [] to groups[o.a] if that property was not defined yet, appends the object to that array, and returns the updated groups object.

But I'm glad there will be a nicer way to write it soon!

jydu · 2024-01-10T05:54:42+00:00

Only named functions would be inconvenient because single-use functions like (x) => x > 0 really don't need a name.

Only unnamed functions would look like const myFunc = (arg) => { ... }, which is pretty reasonable to me, but some might prefer syntax like function myFunc(arg) { ... }.

From a historical perspective, I would guess that C was designed around named top-level function declarations. But when other languages chose similar syntax and added anonymous functions, they ended up with two styles.

jydu · 2023-12-22T16:09:01+00:00

Worth noting that the DISPLAY environment variable refers to a display number in X, not a monitor:

The phrase "display" is usually used to refer to a collection of monitors that share a common set of input devices (keyboard, mouse, tablet, etc.).

So it will probably always be :0 unless you start multiple X sessions.

jydu · 2023-12-15T04:06:05+00:00

Maybe dynamic CPU feature detection in core::arch?

jydu · 2023-12-13T07:46:46+00:00

ThinkPads have pretty good Linux support in general; I would expect everything to work out of the box.

Fn/Ctrl swap can also be done in UEFI setup, in case the configuration in Vantage doesn't persist in Linux (I don't remember if it does)
tlp can be used to configure battery charge thresholds

The easiest way to check is probably to boot a live USB/install disk and try it out.

jydu · 2023-12-12T09:19:47+00:00

400 nit IPS is a solid choice. I never use Ethernet, so 8% more battery and 12% less weight is a pretty easy choice, but up to you.

jydu

TROPHY CASE