109 Followers
336 Following
64 Posts
Software Engineer. See my web site for details: https://www.evanjones.ca/

OK pretty much finished RFC v2 of my relocate anon series.

Many changes... much testing. Seems to work!

A bird that has specialized in transcending the problem of naming proof assistants.
According to an alternate account, an intermediary stage of evolution, stuck in the middle of the transition.

https://moresci.sale/@birds/114191342862047519

Bird of the day (@[email protected])

Attached: 1 image Andean Cock-of-the-rock One of the iconic birds of the Andes. Fairly large, significantly larger and chunkier than a thrush. Found in cloud forest at middle elevations, most often at a dawn display site where males make piglike squeals and jump and dance for females. Sometimes seen elsewhere in the forest, especially at fruiting trees. Males can be either brilliant crimson or orange, always with black wings and broad silver tertials, orange legs, and puffy rounded crest. Female duller brown with smaller crest; note staring pale eye. Nests on large rocks or cliff faces. Only similar species is Guianan Cock-of-the-rock, but no range overlap. Link: https://ebird.org/species/andcot1 Photo Location: Ecuador

SCI小卖部(๑╹ヮ╹๑)ノ 新年灵感贩售中

If you are in NYC, on July 17th I am giving a talk at Datadog about how Random Load Balancing is Uneven. This is a talk version of a blog post I wrote last year, after I ran into this (again). It is easy to assume that if you distribute data randomly, it will be evenly distributed. Unfortunately, it doesn't work that way.

My colleague Janani Rajadurai will also be talking about using open source tools for vulnerability detection.

For details and to RSVP, see: https://lnkd.in/d8ZhYz8e

Original blog post: https://www.evanjones.ca/random-load-balancing-is-uneven.html

LinkedIn

This link will take you to a page that’s not on LinkedIn

If anyone uses prost or tonic for Rust protocol buffers: I was tired of separately installing protoc so I made a crate to do it from a build.rs script. See dlprotoc: https://crates.io/crates/dlprotoc

Feedback welcomed.

crates.io: Rust Package Registry

Some of you folks requested that I write something up about the wacky bug I fixed recently, where JPEG image decoding left the FPU in a bad state on Intel Macs running macOS Sonoma. It was difficult to write—bug hunting isn't particularly exciting, and other deadlines loom—so I hope this satisfies your curiosity: https://supermegaultragroovy.com/2023/11/28/a-bug-hunting-story-how-album-artwork-caused-a-system-wide-loss-of-audio/
A Bug Hunting Story: How Album Artwork Caused a System-Wide Loss of Audio

Capo was not playing audio for some users on Intel Macs running Sonoma. After spending almost two weeks (and about $850) I discovered that macOS Sonoma had a rather nasty bug that was triggered by loading JPEG images.

Setenv is not Thread Safe and C Doesn't Want to Fix It: A bug report, a rant, and some C history, all rolled into one overly long article. We either need to figure out how to improve C, or we should abandon it. https://www.evanjones.ca/setenv-is-not-thread-safe.html

This was inspired by wasting 2 days figuring out why a Go program was crashing in getaddrinfo(), then getting annoyed that no one wants to fix the problem in the C standard library.

In other words: This is mostly screaming into the void to make me feel better.

Setenv is not Thread Safe and C Doesn't Want to Fix It (evanjones.ca)

Random load balancing is not even. I simulated how this leads to sub-linear scaling in distributed systems. Use "two choices" or a large number of items to avoid this problem: https://www.evanjones.ca/random-load-balancing-is-uneven.html
Random Load Balancing is Unevenly Distributed (evanjones.ca)

I was curious how often nanosecond timestamps collide: on Linux, on one thread: never; between two threads: very frequently! Don't assume nanosecond timestamps are unique: https://www.evanjones.ca/nanosecond-collisions.html
Nanosecond timestamp collisions are common (evanjones.ca)

I was curious how much the buffer sizes for read() and write() for TCP and Unix sockets matter for maximum throughput on large transfers. The real answer is that performance varies a lot, but my conclusion is 32 KiB a good starting point, and I would want benchmarks before increasing it further. Large blocking writes can use really large buffers though: around 256 KiB-1 MiB, but reads don't need much more.

Also I am old: You can get more than 1 GiB/s transfers between two machines in a data center today without tuning anything. In the dark ages you would need to do fancy things to go that fast.

Details of my quick and dirty experiments are here: https://www.evanjones.ca/read-write-buffer-size.html

I would love suggestions for making the charts less ugly in a way that won't take my many hours of data wrangling.

How much does the read/write buffer size matter for socket throughput? (evanjones.ca)

If you are in the northeastern US and like databases, I recommend considering attending North East Database Day 2023 on March 10th. It is a nice mix of academic and industrial talks in Boston: https://northeastern-datalab.github.io/nedbday/2023/
North East Database Day, 2023