The x86 TSS is very slow for hardware multitasking and offers almost no benefits when compared to software task switching. (In fact, I think doing it manually beats the TSS a lot of times) The TSS is known also for being annoying and tedious to work with and it is not portable, even to x86-64. … Read more
Well, the answer lives in books: Modern Operating Systems – Andrew S. Tanenbaum is a very good one. The cover illustration below. The simplest yet complete operating system kernel, suitable for learning or just curiosity, is Minix. Here you can browse the source code. (source: cs.vu.nl)
Editor’s note: this is not actually what compilers do, and gives the wrong answer for large positive integers ending with 9, starting with div10(1073741829) = 107374183 not 107374182 (Godbolt). It is exact for inputs smaller than 0x40000005, though, which may be sufficient for some uses. Compilers (including MSVC) do use fixed-point multiplicative inverses for constant … Read more
When people refer to 32-bit and 64-bit assembly, they’re talking about which instruction set you’ll use – they’re also sometimes called Ia32 and x64 in the Intel case, which I presume you’re asking about. There is a lot more going on in the 64-bit case, so starting with 32-bit is probably good; you just need … Read more
Potentially depends on the CPU. However, all modern CPUs (x86, ARM) use a “barrel shifter” — a hardware module specifically designed to perform arbitrary shifts in constant time. So the bottom line is… no. No difference.
I think you’re misreading this statement: For example, many modern 3-D Games have their high performance core engine written in C++ and Assembly. Games (and most programs these days) aren’t “written in assembly” the same way they’re “written in C++”. That blog isn’t saying that a significant fraction of the game is designed in assembly, … Read more
How about a C++-ish way? namespace GPIO { static volatile uint32_t &MAP0_MODER = *reinterpret_cast<uint32_t*>(0x4000); static volatile uint32_t &MAP0_OTYPER = *reinterpret_cast<uint32_t*>(0x4004); } int main() { GPIO::MAP0_MODER = 42; } You get autocompletion because of the GPIO namespace, and there is no need for dummy padding. Even, it is more clear what’s going on, as you can … Read more
Vectorization (as the term is normally used) refers to SIMD (single instruction, multiple data) operation. That means, in essence, that one instruction carries out the same operation on a number of operands in parallel. For example, to multiply a vector of size N by a scalar, let’s call M the number of operands that size … Read more
The call stack could also be called a frame stack. The things that are stacked after the LIFO principle are not the local variables but the entire stack frames (“calls”) of the functions being called. The local variables are pushed and popped together with those frames in the so-called function prologue and epilogue, respectively. Inside … Read more