I do understand that it's sad they don't calculate orthographic images from that to replace their satellite views in these areas though; full 3D is severely more resource intensive on the client after all.

The major difference is that this doesn't have a natural moment to transform/touch the values after read from global and before storage to shared.

Otherwise, tiled MMA (gemm) kernels where normal even in Maxwell days (after the classic K80, before the P100; Maxwell is when H.265 support landed).

My benchmark there is a ventilated attic with insulation between attic and house, using traditional glass roof structure filled with frameless glass-glass panels instead of human-below rated laminated safety glass.

Like, it can't be that hard to do better when you're not trying to be substantially fancier than a classic gable roof, it's just that the panels need to not be shear-loaded much, and the structure doesn't have to be so pretty from underneath as traditional glass roofs.

Built facades and roofs out of glass-glass PV laminate. We have the technology from glass roofs/facades; you just add glass-catching-mesh/insulation below because you can't use the insulated multi-pane window glass construction with safety lamination and solar cells all three together.

We're at the point where 25GBaud PAM4 is being replaced by 50GBaud PAM4. That's 50 to 100 Gbit/s.

But iirc the use of PAM4 for the faster ones than "only" 25Gbit/s lanes is a hindrance to managing bottom-barrel price-per-bit. PCIe 3 was 8, PCIe4 was 16, and PCIe 5 is 32 GBaud with a line code basically like the 10+ Gbit/s Ethernet links (well, it's 66b/64b for Eth and 130b/128b for PCIe).

Profit.

Just hard to get the stuff it seems, mostly because the market has a fetish for early-gen retrofit/independent solar panels, as far as mounting goes.

You get cache locality from the upper layers, and for navigation basically `let mut head = keyspace.min(); 'outer: while(!cursors[0].finished()){ for(&mut cursor in cursors.iter_mut()) { let new_head = cursor.seek_to_target_or_next_after_if_none_match(head); if (head != new_head) {continue 'outer; }} /* passed all without seeking past target on any one */ output_fun(head, cursors.iter().map(|x| x.val())); }`. If you want you can do the inner loop's seeks concurrently, which helps if those are IO latency bound and you can afford to waste absolute IOPS on eagerly doing that. You'll want to locally compute the max() of those returned and assign that to `head`. Imagine the cursors are lambda-parametrized to feel like they operate on the projected shared keyspace.

If the keys are a bitstring prefix suited to a binary prefix trie you can actually intersect that way, it's beyond worst case optimal when multiple key columns are involved. Sadly any simple implementation strategies of those algorithms have prohibitive external-memory-machine coefficients for their nominally poly-logarithmic IOPS, due to involvement of combinatorial explosion / curse of dimensionality in search tree/trie structures. They do work though. C.f. "Tetris-LoadBalanced"/"Tetris-Reordered".

The latter even tames one index containing "all" even numbers and the other "all" odd numbers, well, matters more if you involve 3+ columns :D

It's surely no 64 bit but it's much more than 32 bit. And it's giving you access to the high halves so you can use it to compute 32x32->64 on vector even if only half as packed as that could be.

The refresh that we do is run in parallel on the memory arrays inside the RAM chips completely bypassing any of the related IO machinery.

Considering that the persons involved can't be expected to not be deaf, or functionally so via e.g. headphones, and thus you always have to be able to brake anyways. Running onto a driving lane (be it bikes or cars doesn't matter) without looking especially if the direction you didn't look just gave an audible warning is always reckless.

An ancient gas-e-bike rating is allowed on them outside city limits but iirc those bikes are exceedingly rare since even before e-bikes became truly mainstream.