dadatel :: pouët.net

update is soon(and it will support C and CPP)

here's a little example of some code

Code:

static inline void NoCRT_memset_nt(void* ptr, int value, size_t num) {
    // for lil buffers NT instructions are bad( (bcuz of cache sheesh)
    // REP STOSB (ERMS) on lil and medium blocks will work fine
    if (num < 4096) {
        __stosb((unsigned char*)ptr, (unsigned char)value, num);
        return;
    }

    NoCRT_init_cpu_features();
    unsigned char* p = (unsigned char*)ptr;
    unsigned char val8 = (unsigned char)value;

    // AVX-512
    if (NoCRT_cpu_avx512) {
        // align to 64 bytes to prevent hardware errors and #GP
        while (((uintptr_t)p & 63) != 0 && num > 0) {
            *p++ = val8;
            num--;
        }

        // do shit after aligning, i am a dumbass
        size_t n512 = num >> 9;  // how many blocks with 512 byte(8amount*64byte)
        size_t rem = num & 511; //what remains after da big blocks

        if (n512) {
            __m512i v = _mm512_set1_epi8((char)value);
            for (size_t i = 0; i < n512; i++) {
                _mm512_stream_si512((__m512i*)(p + 0), v);
                _mm512_stream_si512((__m512i*)(p + 64), v);
                _mm512_stream_si512((__m512i*)(p + 128), v);
                _mm512_stream_si512((__m512i*)(p + 192), v);
                _mm512_stream_si512((__m512i*)(p + 256), v);
                _mm512_stream_si512((__m512i*)(p + 320), v);
                _mm512_stream_si512((__m512i*)(p + 384), v);
                _mm512_stream_si512((__m512i*)(p + 448), v);
                p += 512;
            }
        }

        //fill what remains with blocks to 64bytes
        size_t n64 = rem >> 6;
        if (n64) {
            __m512i v = _mm512_set1_epi8((char)value);
            for (size_t i = 0; i < n64; i++) {
                _mm512_stream_si512((__m512i*)p, v);
                p += 64;
            }
        }

        // give tail to stosb
        size_t tail = rem & 63;
        if (tail) {
            __stosb(p, val8, tail);
        }
    }
    //AVX2
    else if (NoCRT_cpu_avx2) {
        //aling to 32bytes
        while (((uintptr_t)p & 31) != 0 && num > 0) {
            *p++ = val8;
            num--;
        }

        // count after align fuck
        size_t n256 = num >> 8;  //blocks to 256 bytes(8amount * 32bytes)
        size_t rem = num & 255;

        if (n256) {
            __m256i v = _mm256_set1_epi8((char)value);
            for (size_t i = 0; i < n256; i++) {
                _mm256_stream_si256((__m256i*)(p + 0), v);
                _mm256_stream_si256((__m256i*)(p + 32), v);
                _mm256_stream_si256((__m256i*)(p + 64), v);
                _mm256_stream_si256((__m256i*)(p + 96), v);
                _mm256_stream_si256((__m256i*)(p + 128), v);
                _mm256_stream_si256((__m256i*)(p + 160), v);
                _mm256_stream_si256((__m256i*)(p + 192), v);
                _mm256_stream_si256((__m256i*)(p + 224), v);
                p += 256;
            }
        }

        // blocks to 32bytes
        size_t n32 = rem >> 5;
        if (n32) {
            __m256i v = _mm256_set1_epi8((char)value);
            for (size_t i = 0; i < n32; i++) {
                _mm256_stream_si256((__m256i*)p, v);
                p += 32;
            }
        }

        // well tail duh
        size_t tail = rem & 31;
        if (tail) {
            __stosb(p, val8, tail);
        }
    }
    // SSE2
    else if (NoCRT_cpu_sse2) {
        // align to 16bytes
        while (((uintptr_t)p & 15) != 0 && num > 0) {
            *p++ = val8;
            num--;
        }

        // do this after aligning damn it
        size_t n256 = num >> 8;  // blocks to 256bytes(16amount * 16byte)
        size_t rem = num & 255;

        if (n256) {
            __m128i v = _mm_set1_epi8((char)value);
            for (size_t i = 0; i < n256; i++) {
                _mm_stream_si128((__m128i*)(p + 0), v);   _mm_stream_si128((__m128i*)(p + 16), v);
                _mm_stream_si128((__m128i*)(p + 32), v);  _mm_stream_si128((__m128i*)(p + 48), v);
                _mm_stream_si128((__m128i*)(p + 64), v);  _mm_stream_si128((__m128i*)(p + 80), v);
                _mm_stream_si128((__m128i*)(p + 96), v);  _mm_stream_si128((__m128i*)(p + 112), v);
                _mm_stream_si128((__m128i*)(p + 128), v); _mm_stream_si128((__m128i*)(p + 144), v);
                _mm_stream_si128((__m128i*)(p + 160), v); _mm_stream_si128((__m128i*)(p + 176), v);
                _mm_stream_si128((__m128i*)(p + 192), v); _mm_stream_si128((__m128i*)(p + 208), v);
                _mm_stream_si128((__m128i*)(p + 224), v); _mm_stream_si128((__m128i*)(p + 240), v);
                p += 256;
            }
        }

        //blocks to 16byte
        size_t n16 = rem >> 4;
        if (n16) {
            __m128i v = _mm_set1_epi8((char)value);
            for (size_t i = 0; i < n16; i++) {
                _mm_stream_si128((__m128i*)p, v);
                p += 16;
            }
        }

        //well ye tail
        size_t tail = rem & 15;
        if (tail) {
            __stosb(p, val8, tail);
        }
    }
    // old CPU fallback
    else {
        __stosb(p, val8, num);
    }

    // finalize well make sure that shit goes to RAM
    _mm_sfence();
}

this code will changed anyways

x64asm still stays as Header only library without CRT
full documentation will release after the main release(bcuz im lazy and i didn't documented everything along the way, but still comments are good for understanding what's and why is happening)

didn't really understanded you correctly i think, so uhh if you're saying why doing this when Xbyak and it's other analogs exists im gonna say, this solution is more optimized and X64 MSVC only and you don't need to do a lot of manipulations with IDE or any other stuff, just include x64_asm.h and done

if shortly this solution with less abstractions than any other(well or that i know) other solutions

heya nerds
so, this is a highly optimized x64 assembler library featuring an ultra-fast JIT compiler engine tailored for MSVC.
the project is currently a Work In Progress (WIP), so the library is not 100% finished yet, but the core engine is fully working. released it early to get some initial feedback from low-level optimization geeks and intro coders(and other dudes).
check out the repository and feel free to test or benchmark it
feedback and bug reports are highly appreciated.

dadatel information 6 glöps