codingspirit

@IchBins1793181 @h_ayguen @Jaibee8Gee Ich sehe jetzt die Space Leiste unten nicht mehr!

@h_ayguen @Jaibee8Gee Richtig

Getting there, eventually. Self-hosted WEBSPY SDR from a RPi5 using an Airspy R2. You can try it: prog.airspy.com:33334

@straceX Controlling UB makes us to magicians 😉😂

C++ engineers fear undefined behavior the way sailors fear the sea: professionally, and while living on it.

Good progress. All the mode work fine and the streaming seems to be smooth. The SpyServer streams the main FFT and the IF IQ. The DSP is done in the browser. #airspy

You can try it (note http, not https - for now) sdr.airspy.com/webspysdr

@atorstling @StokeWillie But only as view.. it's not modifiable, with remove or append

@codingspirit_de @StokeWillie Yes, well std::vector was never a good general view type anyways. std::span does the job better.

In C++26, a standard "in-place" vector can provide contiguous storage for non-movable, non-copyable, non-default-constructible types.

@StokeWillie span isn't modifiable inside the function: no remove, no append, .. and of course, you need to modify the function to accept span - instead of vector

@codingspirit_de It’s called std::span. All standard C++ contiguous containers can be implicitly converted to a corresponding span.

@atorstling @StokeWillie Yes, that works .. but you have a new incompatible type! x.com/i/status/20719…

@StokeWillie Thanks. I recently ran into a use case for this, not having access to C++26, and I figured out that you can also implement a similar container with std::allocator. It allows you to easily allocate contiguous uninitialized storage without needing to fiddle with byte arrays.

In a multi-process system, futexes use a global kernel hash table to track waiters, adding overhead. If your threads share memory but are in the same process, FUTEX_PRIVATE_FLAG tells the kernel to skip the shared hash, drastically reducing lock latency.

This is a brilliant article. SmallVector::push_back() seems simple: if (size == capacity) grow(); data[size++] = value; But its performance is mostly decided by compiler code generation, not the algorithm. The fast path ("size < capacity") is executed almost every time. The slow path ("grow()") only runs when the inline buffer is full. Since "grow()" is a function call, it can overwrite caller-saved registers. If both paths share the same "store element" block, the compiler often has to spill registers to the stack and reload them after "grow()", increasing register pressure and instruction count. The below article explains that tail duplication produces better assembly: - Fast path -> store -> return - Slow path -> "grow()" -> store -> return Instead of merging both paths into one shared store block. The result: • No unnecessary register spills on the hot path • Better register allocation • Fewer loads/stores to the stack • Smaller hot code for better I-cache and instruction decode efficiency LLVM's shrink-wrapping optimization can't solve this because the problem isn't the function prologue, it's the shared control flow after "grow()". A great example of how control-flow layout and register allocation can matter more than the data structure itself. Saving just a couple of instructions in a function called billions of times can noticeably reduce LLVM compile time.

Before C++20, implementing efficient condition variables meant wrapping OS-level futex or pthread_cond. C++20 added wait and notify directly to std::atomic, allowing the compiler to map directly to the fastest OS primitive without mutex overhead.

The Kalman filter isn't a separate algorithm. It's recursive least squares wearing a state-space costume. That's the actual conclusion of Tony Lacey's tutorial. Most people learn the KF as a tool. This is the KF as what it actually is. Bookmark! Worth ten minutes.

Optimized 1024 * 1024 matrix multiplication in pure C from naive to tiling to SIMD avx register on my i3 2nd gen CPU and benchmark it against OpenBlas and here's the result Feel free to explore, modify, benchmark, or improve it. github.com/aadityansha06/…

@PythonPr This is far better - but still no explanation x.com/i/status/20700…

@PythonPr Sorry, this the basic demonstration of how a neuron fires .. but it does NOT explain how neural networks or machine learning works at all!

How AI really works. This tiny operation, repeated across millions of neurons, powers ChatGPT, Grok, image models, and everything in between.

Great companion read brendangregg.com/blog/2017-05-0…

Benjamin Bycroft’s 3D interactive tool visualizes an LLM’s layers, weights and matrix operations. This is the best educational tool to understand how an LLM works i've seen. httpx://bbycroft.net/llm

A Japanese dev open-sourced a drop-in replacement for NumPy that runs on your GPU. It's called CuPy. Change one line import “numpy as np” → “import cupy as cp” and the same code runs up to 100x faster on CUDA. → Works with existing NumPy/SciPy code → No rewrite. No new syntax. → Also supports AMD ROCm 100% Open Source.

It's that time of the year again! Check our generous 20% discount on all #Airspy products during this super hot summer! airspy.com/purchase Our traditional game resumes: #Like and #Retweet to participate and possibly win a #Freebie shipped to you anywhere in the world!

@aadityansha_06 😲😢

I was about to optimize it more and put the methodology of How I did it, However this Sunday I went to thermal paste my CPU and the guy fucked my motherboard, probably would have to buy Tommorow to code again, for last few days it's been irritating for me due to this