In every case (including divisible by 2): if (number % n == 0) do(); Anding with a mask of low order bits is just obfuscation, and with a modern compiler will not be any faster than writing the code in a readable fashion. If you have to test all of the cases, you might improve … Read more
On Linux mmap2 is a sensible system call to use for this at a low level. It takes 6 arguments, so in IA32 you can call it using: mov eax, 192 ; mmap2 xor ebx, ebx ; addr = NULL mov ecx, 4096 ; len = 4096 mov edx, $7 ; prot = PROT_READ|PROT_WRITE|PROT_EXEC mov … Read more
Instruction fetches can be done in chunks with the assumption that much of the time you are going to run through many instructions in a row. so instruction fetches can be more efficient, there is likely a handful or more clocks of overhead per transaction then the delay for the memory to have the data … Read more
CMake supports assembler out of the box. Just be sure to enable the “ASM” language in your project. If an assembler source file needs preprocessing, also set the source file’s compilation options: project(assembler C ASM) set_property(SOURCE foo.s APPEND PROPERTY COMPILE_OPTIONS “-x” “assembler-with-cpp”) add_executable(hello foo.s bar.c)
You’ll need the Linux kernel sources in order to see the actual source of the system calls. Manual pages, if installed on your local system, only contain the documentation of the calls and not their source itself. Unfortunately for you, system calls aren’t stored in just one particular location in the whole kernel tree. This … Read more
Because std::make_unique<int[]>(100) performs value initialization while new int[100] performs default initialization – In the first case, elements are 0-initialized (for int), while in the second case elements are left uninitialized. Try: int *p = new int[100](); And you’ll get the same output as with the std::unique_ptr. See this for instance, which states that std::make_unique<int[]>(100) is … Read more
The move instruction copies a value from one register to another. The li instruction loads a specific numeric value into that register. For the specific case of zero, you can use either the constant zero or the zero register to get that: move $s0, $zero li $s0, 0 There’s no register that generates a value … Read more
Courtesy of William Chan and Google. 30-70% faster than memcpy in Microsoft Visual Studio 2005. void X_aligned_memcpy_sse2(void* dest, const void* src, const unsigned long size) { __asm { mov esi, src; //src pointer mov edi, dest; //dest pointer mov ebx, size; //ebx is our counter shr ebx, 7; //divide by 128 (8 * 128bit registers) … Read more
Unless your 64-bit value can be encoded as a 32-bit-sign-extended immediate, you have to move it to a register first and then store. (Or do two separate 32-bit stores, or other worse workaround to get the bytes where you want them.) In NASM / Intel syntax, mov r64, 0x… picks a MOV encoding based on … Read more
TL:DR: On every modern ISA that has byte-store instructions (including x86), they’re atomic and don’t disturb surrounding bytes. (I’m not aware of any older ISAs where byte-store instructions could “invent writes” to neighbouring bytes either.) The actual implementation mechanism (in non-x86 CPUs) is sometimes an internal RMW cycle to modify a whole word in a … Read more