Welcome to the Lounge

Quote:

I'm excited to hack my toolchain to enable C++20 but I just haven't gotten to it yet.

Quote:

I just now caught up to C++11 variadic templates which allows me to do a lot more metaprogramming (or at least more easily) than I used to be able to do.

Quote:

I'm doing it for now, without using STL for it just because I want to make sure I get the mechanics of any of the library I rely on.

auto rc = SomeFunction();
if( rc != NO_ERROR )
{
    return rc;
}

Quote:

I'm not using iostreams

Quote:

Anyway, I'm still working on it, but what I have so far incurs no overhead for anything.

Espen Harlinn wrote:

it is also a great way to discover that any occurrence of code-bloat has little (if anything?) to do with the C++ language.

Espen Harlinn wrote:

Apart from RTTI and exceptions there should be no overhead compared to C. Personally I use exceptions extensively for error handling, and also I like to think that I write fast code,

Quote:

I'll be writing an article about it soon

Quote:

I think the issue here is that exceptions make your stack bigger

Stuart Dootson wrote:

a whole set of bitmask and bitfield register functions that do as much work as possible at compile-time to ensure that a) bit-mask constants can be used in a constexpr context

honey the codewitch wrote:

Made extra difficult for the fact that in certain cases (like with 1 bit monochrome) I am not reading and writing on byte boundaries, but bit boundaries

using bf1 = bit_field_t<21, 10>;
using bf2 = bit_field_t<31, 24>;
using bf3 = bit_field_t<0, 0>;
using bf4 = bit_field_t<1, 1>;
using bf5 = bit_field_t<2, 2>;
using bf6 = bit_field_t<3, 3>;
using bf7 = bit_field_t<4, 8>;
using bf9 = bit_field_t<6, 6>;
using reg1_t = bit_field_register_t<bf1, bf2, bf3, bf4, bf5, bf6, bf7>;
using reg2_t = bit_field_register_t<bf1, bf2, bf3, bf4, bf5, bf6, bf9>;

int foo(reg1_t *r1) {
  r1->insert<bf1>(123);
  return r1->extract<bf7>();
}

mov     eax, dword ptr [rdi]
mov     ecx, eax
and     ecx, -4193281
or      ecx, 125952
mov     dword ptr [rdi], ecx
shr     eax, 4
and     eax, 31
ret

constexpr inline static int_type at(const uint8_t* bitmap,size_t index) {
    if(native_int) {
        // best case:
        const size_t offs = index;
        return order_guard(*(((int_type*)bitmap)+offs));
    } 
    const size_t ofsb=((index*bit_depth)/8);
    bitmap+=ofsb;
    const size_t ofsm=(index*bit_depth)-(ofsb*8);
    // most general case: (read 1 bit at a time)
    int_type result = 0;
    uint8_t dat = *(bitmap);
    for(size_t i = 0;i<bit_depth;++i) {
        const size_t bit = 7-((ofsm+i)&7);
        const uint8_t msk = (1<<bit);
        const bool mov = bit==7;
        result<<=1;
        result|=(0!=(dat&msk));
        if(mov) // get next byte
            dat=*(++bitmap);
    }
    return order_guard(result);
}
... (below is from main)

typedef channel_traits<channel_name::V,channel_kind::luminosity,uint8_t,1> mono_1bit_luminosity_channel_t;
typedef pixel<color_model::none, false, mono_1bit_luminosity_channel_t> mono1_t;

uint16_t data=0xCCCC;
for(size_t x=0;x<16;++x) {
    auto val = mono1_t::at((uint8_t*)&data,x);
    printf("%d",val);
}
printf("\r\n");
return 0;

main:
        push    rbp
        mov     ebp, 1
        push    rbx
        xor     ebx, ebx
        sub     rsp, 24
        mov     WORD PTR [rsp+14], -13108
.L2:
        mov     rcx, rbx
        mov     rdx, rbx
        mov     eax, ebp
        xor     esi, esi
        not     rcx
        shr     rdx, 3
        mov     edi, OFFSET FLAT:.LC0
        and     ecx, 7
        sal     eax, cl
        test    BYTE PTR [rsp+14+rdx], al
        setne   sil
        xor     eax, eax
        inc     rbx
        call    printf
        cmp     rbx, 16
        jne     .L2
        mov     edi, OFFSET FLAT:.LC1
        call    puts
        add     rsp, 24
        xor     eax, eax
        pop     rbx
        pop     rbp
        ret