tanelpoder

6,469 karmajoined 8 jaar geleden

A long-time computer performance nerd, creator of 0x.tools

blog: tanelpoder.com

Submissions

Benchmarking coding agents on Databricks' multi-million line codebase

154 pointsby tanelpodereergisteren67 comments

High-cardinality metrics at scale: why the standard playbook is wrong

2 pointsby tanelpoder3 dagen geleden0 comments

HammerDB v6.0 Response Times, Percentiles and Reservoir Sampling

4 pointsby tanelpoder8 dagen geleden0 comments

Observability Engineering book, 2nd Edition [pdf]

1 pointsby tanelpoder12 dagen geleden0 comments

Cramming 1M (Scaled to Zero) Virtual Machines in a Single Box

1 pointsby tanelpoder13 dagen geleden0 comments

rdmatop: Cross-Provider Htop for RDMA Traffic

uccl-project.github.io

3 pointsby tanelpoder14 dagen geleden0 comments

Apache Kafka's log compaction corrupts data

3 pointsby tanelpoder15 dagen geleden0 comments

A MCP server that supports mainstream eBook formats including ePub, PDF and more

1 pointsby tanelpoder15 dagen geleden0 comments

Silk is a stackful-fiber library, scheduler with a work-stealing loop, io_uring

2 pointsby tanelpoder15 dagen geleden0 comments

Packet_edit_meme page cache poisoning vulnerability (CVE-2026-46331)

1 pointsby tanelpoder15 dagen geleden0 comments

Modern GPU Programming for MLSys Book

1 pointsby tanelpoder15 dagen geleden0 comments

OpenAI will delay GPT-5.6 after Trump administration request

36 pointsby tanelpoder15 dagen geleden2 comments

Direct I/O for Cassandra Compaction: Cutting p99 Read Latency by 5x

2 pointsby tanelpoder16 dagen geleden0 comments

Show HN: Profiler and Runtime Reporter for eBPF programs (brr)

2 pointsby tanelpoder23 dagen geleden0 comments

[untitled]

1 pointsby tanelpoder23 dagen geleden0 comments

Learning VPP: Filtering Packets at 100GbE Line Rate

haryachyy.wordpress.com

3 pointsby tanelpoder23 dagen geleden1 comments

Hands-On with Flink: Calling LLMs from Flink

2 pointsby tanelpoder27 dagen geleden0 comments

[untitled]

1 pointsby tanelpoder27 dagen geleden0 comments

Glacial Valley

5 pointsby tanelpoder28 dagen geleden0 comments

[untitled]

1 pointsby tanelpoder30 dagen geleden0 comments

comments

vorige maanddiscuss

[flagged]

vorige maanddiscuss

Great article, including the interactive parts that were just simple enough to illustrate the point at high level.

I never got that far, but I once built a little page that just visualized embedding vectors generated from a few hundred cat, dog and plane photos as heatmaps. I used this for demonstrating to database & storage folks what embedding vectors physically are, at low level. The point of the heatmap (of different vectors) was to show that there are visually observable "vertical bands" standing out when plotting out many embeddings of the same types of objects (like different cats with different backgrounds) in a single heatmap.

I then also took a single cat photo, rotated it by one more degree 360 times and created a heatmap of these vectors to illustrate the point of what the embedding models really detect (you have to uncheck the "Normalized" checkbox in the "same cat rotated by 360 degrees" page to see the vertical bands show up).

The web-app is here:

https://tanelpoder.com/catvector/

2 maanden geledendiscuss

GitHub: https://github.com/ilum-cloud/duck_lineage

3 maanden geledendiscuss

It was put into second-chance pool by moderators. I originally submitted this link a few days ago and today got this (semi?)automated email from HN, an excerpt below:

  The submission "OpenAI Privacy Filter" that you posted to Hacker News (https://news.ycombinator.com/item?id=47870901) looks good, but hasn't had much attention so far. We put it in the second-chance pool, so it will get a random placement on the front page some time in the next day or so.

  This is a way of giving good HN submissions multiple chances at the front page. If you're curious, you can read about it at https://news.ycombinator.com/item?id=26998308 and other links there.

4 maanden geledendiscuss

True, I should have been more specific about the context:

Their invention is about pushing down the .eh_frame walking to kernel space, so you don't need to ship large chunks of stack memory to userspace for post-processing. And eBPF code is the executor of that "pushed down" .eh_frame walking.

The GitHub page mentions a patent on this too: https://patents.google.com/patent/US11604718B1/en

4 maanden geledendiscuss

The reference implementation of the profiler [1] was originally built by the Optimyze team that Elastic then acquired (and donated to OTEL). That team is very good at what they do. For example, they invented the .eh_frame walking technique to get stack traces from binaries without frame pointers enabled.

Some of the OGs from that team later founded Zymtrace [2] and they're doing the same for profiling what happens inside GPUs now!

[1] https://github.com/open-telemetry/opentelemetry-ebpf-profile...

[2] https://zymtrace.com/article/zero-friction-gpu-profiler/

4 maanden geledendiscuss

I was doing over 11M IOPS during that test ;-)

Edit: I wrote about that setup and other Linux/PCIe root complex topology issues I hit back in 2021:

https://news.ycombinator.com/item?id=25956670

4 maanden geledendiscuss

Yeah you'd still have the IOMMU DMA translation, but would avoid the interrupt overhead...

4 maanden geledendiscuss

I understand that it's the interrupt-based I/O completion workloads that suffered from IOMMU overhead in your tests?

IOMMU may induce some interrupt remapping latency, I'd be interested in seeing:

1) interrupt counts (normalized to IOPS) from /proc/interrupts

2) "hardirqs -d" (bcc-tools) output for IRQ handling latency histograms

3) perf record -g output to see if something inside interrupt handling codepath takes longer (on bare metal you can see inside hardirq handler code too)

Would be interesting to see if with IOMMU each interrupt handling takes longer on CPU (or is the handling time roughly the same, but interrupt delivery takes longer). There may be some interrupt coalescing thing going on as well (don't know exactly what else gets enabled with IOMMU).

Since interrupts are raised "randomly", independently from whatever your app/kernel code is running on CPUs, it's a bit harder to visualize total interrupt overhead in something like flamegraphs, as the interrupt activity is all over the place in the chart. I used flamegraph search/highlight feature to visually identify how much time the interrupt detours took during stress test execution.

Example here (scroll down a little):

https://tanelpoder.com/posts/linux-hiding-interrupt-cpu-usag...

5 maanden geledendiscuss

The issue in the enterprise (SAN) storage space is that there are so many layers where things can go wrong. Lost writes due to the OS kernel (like the fsyncgate), in-kernel storage interaction drivers, the storage array software itself, then disk firmware etc. Theoretically you could read back the just-written block and check if it’s what you wrote, but maybe it’s returned from some cache, before the bug happened.

Another scenario (OS, driver bugs) is that a correct block is written to a wrong location. Yes the write is persisted, but overwriting a wrong location. So now you have two incorrect blocks.

5 maanden geledendiscuss

Since we are talking cats here, let me plug my CatBench vector search playground app, intended to learn and demonstrate in a visual way how (PyTorch + ViT) image embeddings and (Postgres) vector search work together with your regular OLTP transactional data. I implemented a toy version of a purchase recommendation system based on “cat customer” image similarity and “cat fraud detection” building block too:

https://github.com/tanelpoder/catbench

Also, a simple browser-only page for visually demonstrating what embeddings/vectors physically are, for explaining this to database & storage folks:

https://tanelpoder.com/catvector/

(Initial load of the vector heatmaps may take a few seconds when you click on a pet type)

6 maanden geledendiscuss

GitHub: https://github.com/DataDog/IDE-SHEPHERD-extension

6 maanden geledendiscuss

I went with an overkill approach at first (as I often do :-) and bought some expensive nicely designed "active chair" / stool that was adjustable high enough so that I could lean on it even when using my desk as a standing desk. It was interesting, but not a game changer at all for me. I don't use standing desks now at all.

But what I have now is this:

https://www.amazon.com/dp/B002FL3LY4

Just don't assemble the backrest at first. If sitting up straight, I just lean wrists on my keyboard wristpad and part of forearms on the desk, no armrests needed either.

Edit: I still use my height-adjustable standing desk, but now it's value is that I could adjust it for the perfect height for my sitting-up-straight position (so no chair armrests needed) and it's been fixed at that height for the last 7 years...

6 maanden geledendiscuss

Cool, thanks for the clarification. Indeed it's a good and practical idea for a small app. As other comments have said, (some) people might happily pay for this app.

I luckily won't need such feedback loop anymore, had some mild lower back pain show up over 10 years ago and bought a chair without a backrest that, after 3-4 weeks of struggling, trained me to sit up straight. Now I have some random cheap office chair with a backrest, but I rarely lean back to it. Funnily, I was going to give up using that "backrestless" chair after 2 weeks of inconvenience, but decided to give it one more week and then the magic happened :-) Mild lower back pain automatically gone.

6 maanden geledendiscuss

Once launched, Posturr runs in the background and displays a brief "Claude Mode Active" notification.

I haven’t checked the code yet, but what does the “Claude Mode” mean? Is it a poor naming choice? It implies that the local app is somehow connected to Claude (?)

6 maanden geledendiscuss

(2024)

6 maanden geledendiscuss

There's also a (free) PDF download from Springer

https://link.springer.com/book/10.1007/978-3-031-99489-0

6 maanden geledendiscuss

I also wrote a little Python tool that iterates through syscall tracepoint declarations in debugfs (/sys/kernel/debug) and lists available syscalls and their arguments available in your currently running system:

https://tanelpoder.com/posts/list-linux-system-call-argument...

Debugfs does not show platform-specific syscall internal numbers though (but the stable syscall IDs).

Apparently debugfs does not show all syscalls, excluding "some weird ones" as mentioned by mebeim/systrack author in an earlier HN discussion:

https://news.ycombinator.com/item?id=41018135#41020166

6 maanden geledendiscuss

And with eBPF iterators you can bail out early and move to next if you see a non-interesting item (or one that should be filtered out) instead of emitting textual data of all items and later grepping/filtering things out in post-processing.

I use early bailout a lot (in 0x.tools xcapture) when iterating through all threads in a system and determining which ones are “active” or interesting

6 maanden geledendiscuss

The internals document looks pretty great too. It actually talks of internals and goes pretty wide and deep. Saved for reading later once the coffee kicks in!

https://tidesdb.com/getting-started/how-does-tidesdb-work/