Charles ☭ 
is a GreenThe Fuck Off AI Music Movement's FAQ is 👌
| Homepage | https://veralin.dk |
| GitHub | https://github.com/sqaxomonophonen |
| Pronouns | he/him or they/them |
| Birthyear / favorite tempo | 339ppm / 133bpm |
aks
@sqx
- 41 Followers
- 96 Following
- 504 Posts
Lu wilsonrecording from the final seconds of nudel's life from another jammer
Liam ProvenGalileo's Basilisk
https://hexmhell.writeas.com/galileos-basilisk
<- an eloquent counter to Rationalism, LessWrong, TESCREAL, the Singularity, the rise of AI and AGI, and what's more, it's fun!
@ahihi @froos ooh, i'm not familiar with it, but C dependencies tend to be a pain unless they can be vendored. we used to compile with emscripten which provides libc/libm/etc, but ended up doing the nostdlib clang thing because it felt better i guess :) (also, a personal excuse is that emscripten works poorly on freebsd)
@froos probably best to avoid malloc/free as much as you can, like the static mem stuff in dough.c, but in audio engines you have samples and delay buffers as these things that can have any size, and may come and go… i'm thinking k&r malloc might be fine for those
frooshow to make your cross-platform audio engine bloat free in 5 easy steps: https://garten.salat.dev/135-clang-wasm-audio/ (i almost fell off the chair when i saw step 4). shoutout to @sqx
@froos i've since found simple replacements for the remaining stuff i usually miss from libc:
qsort: i turned this macrofied qsort back into a stdlib.h-compatible one: https://github.com/nothings/stb/blob/31c1ad37456438565541f4919958214b6e762fb4/deprecated/stb.h#L8721-L8846
malloc/free: turns out the original K&R book ("The C Programming Language") chapter 8.7 has an elegant malloc, meant as a teaching example, but it works: https://github.com/noncombatant/kr-malloc/blob/main/original_kr_malloc.c
Jens Gustedt's BlogDefer available in gcc and clang
About a year ago I posted about defer and that it would be available for everyone using gcc and/or clang soon. So it is probably time for an update.
Two things have happened in the mean time:
- A technical specification (TS 25755) edited by JeanHeyd Meneide is now complete and moves through ISO’s complicated publication procedures.
- Both gcc and clang communities have worked on integrating this feature into their C implementations.
I have not yet got my hands on the gcc implementation (but this is also less urgent, see below), but I have been able to use clang’s which is available starting with clang-22.
I think that with this in mind everybody developing in C could and should now seriously consider switching to defer for their cleanup handling:
- no more resource leakage or blocked mutexes on rarely used code paths,
- no more spaghetti code just to cover all possibilities for preliminary exits from functions.
I am not sure if the compiler people are also planning back ports of these features, but with some simple work around and slightly reduced grammar for the defer feature this works for me from gcc-9 onward and for clang-22 onward:
So this is already a large panel of compilers. Obviously it depends on your admissible compile platforms whether or not these are sufficient for you. In any case, with these you may compile for a very wide set of installs since defer does not need any specific software infrastructure or library once the code is compiled.
As already discussed many times, the gcc fallback uses the so-called “nested function” feature which is always subject of intense debate and even flame wars. Don’t worry, the implementation as presented here, even when compiled with no optimization at all, does not produce any hidden function in the executable, and in particular there is no “trampoline” or whatever that would put your execution at risk of a stack exploit.
You may also notice that there is no fallback for older clang version. This is because their so-called “blocks” extension cannot easily be used as a drop-in to replace nested function: their semantics to access variables from the surrounding scope are different and not compatible with the defer feature as defined by TS 25755.
So for example if you are scared of using big VLA on the stack, you may use the above code in headers and something like
double* BigArray = malloc(sizeof(double[aLot])); if (!BigArray { exit(EXIT_FALURE); } defer { free(BigArray); }to have an implementation of a big array with a failure mode for the allocation.
Or if you want to be sure that all your mutexes are unlocked when you leave a critical section, use and idiom as here
{ if (mtx_lock(&mtx) != thrd_success) { exit(EXIT_FAILURE); } defer { mtx_unlock(&mtx); } ... do something complicated ... if (rareCondition) { return 42; } ... do something even more complicated ... }Just notice, that you’d always have to use the defer feature with curly braces to ensure that the gcc fallback works smoothly.
lcamtuf 