smallpipe

The tool is also pretty abysmal at telling you why it can’t parse the thing you wrote. For me that was the reason #1 it’s hard to learn.

The other reason I don’t use it is that it’s very hard to inspect what you’re running. You can’t write something like “a trace of X state transition must be possible within N cycles with the right inputs”. It makes it really hard to convince yourself (and your peers) you haven’t assumed all of the state away.

Fantastic news. It’s such a debilitating disease even for people who don’t die from it. A whole life of frequent crises.

A great TL;DR from Matthew Green is available at [0]

[0] https://twitter.com/matthew_d_green/status/14051691818808934...

Modern embedded cores have self-testing code that detects anywhere from 50% to 90%[1] of faults in the hardware, including from ageing.

If google and the other hyperscalers complain enough, there’s no reason Intel couldn’t give them some self test to run every hour or so.

[1] depends on how complex the CPU is, how long you accept to run the self testing code, and how well it was done.

That’s called dual core lockstep and it’s very common in automotive and other applications where reliability is paramount.

For the scroll direction check this out https://pilotmoon.com/scrollreverser/

Interesting that you chose to actually host it given the time constraints! I would probably cheat and run a server locally (say python -m http.server 80) and add the domain to /etc/hosts

This is fun and all, but the benchmarks here aren't really what the author seems to think they are. This isn't "computationally expensive", the script is basically only control flow, where the CPU spend more time doing variable lookups than the actual computation. This means most of the pipeline width sits completely unused, whcih is a pretty large disservice to the M1 and the i5.

There's also no control for the thermal throttling of the M1, which is probably why the 100,000 example is performing worse.

> "Apple is complicit and profiting from piracy by selling phones on which it's trivial to install pirated games".

I'm not seeing any of these headlines with Android

Using completely wrong greek letters in the title is making me very uneasy for no good reason

I’ve used it to copy a matlab library into hobby software, whilst being able to debug it to compare.

Details in my previous comment: https://news.ycombinator.com/item?id=25441585

Thanks for the tip! I’ll have to go back and check.

Octave is fantastic.

Just yesterday I was trying to help find a bug in a hobby GPS software, where the map projection was off by a bit, resulting in surfaces that were off by 5% compared to Google Earth. Someone had written a little library for matlab and gave it away on the mathworks website.

Being able to test that library without matlab, confirm it was working, then using Octave to debug the translated code was invaluable.

After debugging and confirming both version gave the same result, we were closer to the Google Earth solution, but still off by a bit. That’s when we learned the projection used by GE isn’t very good to compute surfaces, and ours was actually doing a better job. Octave turned day+ job into a one hour session.

Massive thanks to the authors, and the author of that matlab library!

Something I don't really understand coming from arch, how am I supposed to handle the system installation?

Why is partitioning not part of a config file, but done at installation?

Very true, but that’s the classic 32b arch only, aarch64 is much cleaner. The next big A class CPUs will be aarch64 only.

Cambridge is small enough, and cycle-friendly enough that nothing is more than 15 minutes away. Bumper-to-bumper is a choice (assuming you live reasonably near the centre)

Low background lead was recently mentioned on xkcd[0]. Maybe that circled back to HN?

[0] https://xkcd.com/2321/

I don't think the explanation for fill_array.c and fill_array_out_of_order.c is correct. Unless you're running on a massive server, you're not getting anywhere near 300MB of cache.

Modern CPUs have optimizations that bypass L1 and L2 cache allocation for a continuous burst of writes without reads, so the result here is main memory write speed, not cache allocation.

Python might have changed since this was written, but on my machine, with any number, it finishes in 0.0s!

My understanding was that to access a variable, python does a dictionary lookup to match the name to a memory location, which would explain what happens with an older python.