I usually put an inline wrapper around vtable functions so that `thing->vtable->foo(thing, ...)` becomes `foo(thing, ...)`.
Readit Newsaccelbred commented on Object-oriented design patterns in C and kernel development oshub.org/projects/retros... · Posted by u/joexbayer
accelbred commented on Anker is no longer selling 3D Printers theverge.com/report/71400... · Posted by u/geerlingguy
This has been my experience, and I've found the price seems to reasonably reflect the quality one can expect.
I've had a few Anker power related devices, those pushing £100+ seem to be of better quality, I recently bought a new GAN charger for ~£80 and it's decent, but I also bought a 20000 mAh power bank on sale for ~£15 and it was one of the recalled models.
Their cables generally seem to be pretty reliable too, but I draw the line at "accessories" and wouldn't buy anything "intelligent" from them, cameras, other IoT devices etc.
I wouldn't buy cables from them. Their 100W cables dont work even with their own 100W chargers. Bought multiple at different times, since I'd been using them with 60W chargers before. All of them had the same issue with dropping out with 100W chargers from Anker or other brands. I ended up throwing them all out and getting 100W cables from another brand, and those have been quite reliable.
Sorry what do you mean by "symbol interpolation" and "interposition" in this context?
Natively I would assume you can just take the sections out of the shared object and slap them into the executable. They're both position independent so what's the issue?
If PIE allows greater assumptions to be made by the compiler/linker than PIC that sounds great for performance, but doesn't imply PIC code won't work in a PIE context.
PIC code would work where PIE does, but likely perform worse. In shared libraries, calls to any non-static function can't be assumed to be the same function at runtime, since another library linked or using LD_PRELOAD may also define the symbol. Thus all calls to non-static functions must go through the shared library lookup machinery. This prevents inlining opportunites as well. Functions in an executable can't be overwridden in this manner, and override the symbols in shared libraries. Thus PIE code can have cheaper function calls and freely inline functions.
Its not that you couldn't use the PIC code, but it would be better to just recompile with PIE.
accelbred commented on I watched Gemini CLI hallucinate and delete my files anuraag2601.github.io/gem... · Posted by u/anuraag2601
This post feels uncomfortably a lot like Claude generated text.
Something I've never quite understood is why can't you statically link against an so file? What specific information was lost during the linking phase to create the shared object that presents that machine code from being placed into a PIE executable?
so files require PIC code, which brings along symbol interpolation.
Which IDE or editor are you viewing this proportional font in?
A proportional font in Emacs doesn't look right to my eye. My guess is that there are subtleties in the spacing between letters when a browser or a book publisher renders the text that Emacs does not know about.
Emacs should also be doing kerning. I use proportional fonts for non-prog-mode buffers and no issue here.
Is there a magit equivalent? I heavily use magit's interactive features and extensions to the git UI (like spinoff, absorb, or the auto-backup thing)
accelbred commented on How to handle people dismissing io_uring as insecure? (2024) github.com/axboe/liburing... · Posted by u/nromiun
* An abstraction over second level page tables to map some of a host user process as what the guest thinks of as physical memory.
* An abstraction to jump into the context that uses those page tables, and traps back out in the case of anything that the hardware would normally handle, but the hypervisor wants to handle manually instead.
* A collection of mechanisms to handle some of those traps in kernel space to avoid having to context switch back out to the host user process if the kind of trap is common enough, both in the sense of the trap itself happens often enough to show up on perf graphs, as well as the abstraction being exercised is relatively standard (think interrupt controllers and timers).
Let me know if you have any other questions.