Asmod4n

Jup, all currently running containers got deleted on my account. Hope you guys got your stuff pushed to somewhere before the outage.

I am building something similar, with c++26 reflection. So any language can use c++ libs with only a few lines of boilerplate in a lifetime and memory safe way where possible. And where it’s not possible to infer the safe lifetime of an object i got a small .toml file which tells the lib how to safely use those functions.

Well, let’s hope rust is better than std::simd from c++ here which lacks the capability to emit some intrinsics.

Gcc and llvm can tell you if they can’t Auto vec a function, maybe rust could turn this into an error at comptime.

The issue with libraries which offer you portable simd is that the auto vectorizer of the compiler will likely generate faster code.

So far all sessions I’ve started with opus 5.5 have avx512 support, not like all other models where it’s a dice roll each chat.

sysadmins CI is hoping the machine still boots after an update. Unless you are lucky you got two identical machines to have a test env.

Loads of hosting sites do this, username.domain.tld is the most common one.

Sadly glibc made the choice for everyone that you have to recompile constantly to keep your app working.

That’s one of the biggest issues keeping Linux small on the desktop since nearly no commercial oriented company works that way.

But it looks like we will soon be able to „virtualize“ the dynamic loader so glibc has no say in this matter anymore.

Win32 is the most stable abi on the Linux desktop.

The tv does care which port it came from, since it automatically switches to the one which made the request.

One could build a IR emitter but you need soldering skills for that or buy a usb one which cost north of 30€ + shipping.

There is sadly no hdmi CEC support on Most GPUs for pcs. So when you want your tv to turn on and off with your pc it is only possible with the tv being reachable from your pc via ip.

I believe LG doesn’t advertise such an api via Bluetooth

to not let the bytes i forward enter userspace, i serve from the page cache for the asset path, directly from a zip file.

i open the file, mmap it, close it and tell io_uring_prep_send which bytes from the mapping to send, this also saves me from a possible SIGBUS cause the access to the mmap happen inside the kernel, and when a SIGBUS would happen in userspace the kernel just reports a shorter send in cqe->res

How can one memcpy from a fd to a socket? I don’t touch the bytes in userspace, I just tell the kernel to send them out.

For responsiveness that’s what you want, context switches add quite a lot of jitter and perceived slowness’s, making your app feel slow despite running at 120 fps.

Tried every way to get contents of a file as fast to a client socket as possible.

mmap and io_uring_prep_send were faster than everything else, no matter the size as long as you keep the map around for the lifetime of the process.

for one off sends when a file is smaller than 256kb then io_uring_prep_read + prep_send are faster than everything else.

In my case: its a PROT_READ, MAP_PRIVAT map and i cannot get a SIGBUS since i tell the kernel to handle it all for me, thanks to liburing, instead i get a short send in that case.

To be more precise: i use that map to send assets out directly to clients from a zip file.

Its a new web server i am building and its the fastest way i could find out.

Just switching from epoll to liburing made the server ~45% faster too, its ridiculous. It can serve 10 gigabyte per second with a single thread, or around 10 million responses per second with h2 and 32 multiplexed requests.

I had to write a new http load generator for that since i couldn't find one which could generate enough load to saturate my server or be fast enough to withstand it.

I found out that using mmap and just telling uring to read form there to beat anything else.

Firefox is still popular in Germany, at around 10%

>I would think that the German state or EU should provide funding for his museum. If that's not the case, it's a shame.

There is another Museum of his, which is still funded.

how do they handle that malloc aint async signal safe?

You can have virtually unlimited amount of rules, its just a limit per list, the number of lists aint really limited.

The main Question is: why do you allow clients to connect to your database server, it should be limited to a server which could actually serve the data in a format the client can just render without any logic client side.

Network IO is heavily NIC queue bound, if your NIC only has one queue it just makes it slower to do any threading workload against it.

On my ryzen 9 it needs around 8 cores to do the same work in a threaded io loop than you can do single threaded. And the mechanism doesnt matter, you could share an fd, use SO_REUSEPORT or just share memory between threads.

Just doing the sharing makes everything extremely slow. One context switch becomes more expensive than just doing it single threaded.

Routers got such a thing build in nowadays, just gotta enable it (not the ones from your ISP of course)

Edge tabs show up in alt + tab.

Just curious, can’t this be done using a bookmarklet? Albeit it being a bit clunky to use compared to a userscript which runs automatically.

it's finally the year of linux on the desktop! :)

Wait, does this mean we can „virtualize“ ld.so now? This could finally solve the compatibility issues glibc causes.

zurl and mongrel2 are using it.