winwang

Fun fact which I'm 50%(?) sure of: a single branch divergence for integer instructions on current nvidia GPUs won't hurt perf, because there are only 16 int32 lanes anyway.

Congrats! How do you guys deal with SOC2/HIPAA/etc.? Or are those separate concerns?

I've seen shops (e.g. Netflix I think) use Datalog for certain query types.

This might unironically be a reason for me to finally try Clojure!

Sorry, I was just trying to make a joke (about both insane systems and interview questions) since the question you answered was a bit unclear. Guess it didn't land, haha.

how would you do it if your logs were printed on paper with a printer, each line printed with stochastic timing (due to a bug), with an ink containing a chemical tracer with halflife `h` (after being put to paper), but the ink is randomly sampled from several (`m`) inks of different halflives `h1`, h2`,... `hn`? assume `p` different printers scattered across the 10 most populous US cities. you may use standard unix utilities.

> the need is to be able to provision access after the relationship is established

Could you go into more detail? At a base level interpretation, this is how it works already (you need a principal to provision access for...), but you presumably mean something more interesting?

Slightly disagree at least for GCP. It will error with a detailed permission, but you're not just going to add that -- you're going to add a role (standard, unless you have custom roles), which you technically have to map back to the permission you need. But also, those (standard) roles have many permissions in one, so you likely overprovision (though presumably by just a bit).

...If only we could do something like: dry run and surface all the required permissions, then grant them in one fell (granular) sweep.

What do people think about pixi?

Couple of reasons. 1. You can use vram when you don't have massive amounts of ram for a ramdisk (or /dev/shm) 2. Depending on implementation, you might have faster random seek/write than normal ram. 3. You could presumably run certain gpu kernels on the vramfs.

5. steganographic subliminal messaging :P

Hard to argue against engagment being good overall, but I think we need some kind of "regularization".

There is always an algorithm, explicit or not, "malicious" or not.

For implicit algorithms, outside of the issues/misincentives of time-sorted feeds, there's also game theory and behavioral economics.

Are they really too specific? https://arxiv.org/abs/2303.01139

Well, it's not that the results were good though, lol.

The domain doesn't seem to be available?

Having talked to many engineers using distributed compute today, they seem to think that (single-node) parallel compute haven't changed much since ~2010 or so.

It's quite frustrating, and exacerbated by frequent intro-level CUDA blog posts which often just repeat what they've read.

re: raytracing, this might be crazy but, do you think we could use RT cores to accelerate control flow on the GPU? That would be hilarious!

With my minor dabbling in game theory, I've considered funny angles like secret-ish internal metrics and punish those who simply game the incentives. Example: bot detections and banwaves in MMOs. Instead of instantly banning plausible bots, the company has to hide its (ever-changing) internal algo and ban in waves instead.

Basically, treating (non-)productivity like bot detection, lol.

Thanks for the share (and reminder)! Turns out I had this bookmarked somehow, lol.

That's wild and inspirational. Like the scene in Rush Hour when a stack of bills saves Tucker from a bullet.

Though I'm moreso tempted to just create a `.1111aaaa-antidumb` directory and store my caches and backups there.

This has also un-inspired me from creating a fast `rm`-esque utility.

Personal opinion: it's the software (and software tooling).

The hardware is good enough (even if we're only talking 10x efficiency). Part of the issue seems slightly cultural, i.e. repetitively putting down the idea of traditional task parallelism (not-super-SIMD/data parallelism) on GPUs. Obviously, one would lose a lot of efficiency if we literally ran 1 thread per warp. But it could be useful for lightly-data-parallel tasks (like typical CPU vectorization), or maybe using warp-wide semantics to implement something like a "software" microcode engine. Dumb example: implementing division with long division using multiplications and shifts.

Other things a GPU gives: insanely high memory bandwidth, programmable cache (shared memory), and (relatively) great atomic operations.

Unless you make the candle out of better materials.

What I mean is that isn't the temperature of "space" -- if we're being pedantic. Such a temperature would presumably be measured by the blackbody radiation of... space, if space were a blackbody.

Is that really "space" as opposed to "the lingering effects of the big bang"? (or less interestingly, the temperature of the CMB photon gas)

Are there benchmarks you can share? Not discounting Rust, just wondering if you're already seeing some obvious numbers.

Sounds similar to Haskell "do" notation where it can look procedural, but backed by FP principles and tools.

(Something something monads are sequentialness)

"A sufficient smart compiler..."

Thank you, this type of info is pretty much exactly what I hoped to learn :D

Love your notes explaining some of the GPU thread-indexing concepts!

Shameless plug for my own little post going a bit into the performance benefits of "vectorized" sorting, even vs. programmable L1 cache: https://winwang.blog/posts/bitonic-sort/

Not a database engine, but I'm processing distributed dataframes (~400TB). We're seeing a perf/price ratio around 3x~4x, though it's only a limited sample of workloads/datasets. (Note: we are not sorting, yet)

As far as I can tell, it's less so that the payoff is small, but that the payoff is small considering the maturity/scarcity of GPU programming, and availability of GPUs (esp. on-prem).

I don't use it because it didn't seem stable for CUDA when I tried it out.

As for number crunching, I'd probably use CuPy (outside of the typical ML stuff).