Welcome to the Lounge

Espen Harlinn skrev:

And, now that we have ranges, I guess many C++ developers will do pretty sophisticated meta-template programming without even realizing it - and suddenly it will not be scary anymore

Quote:

Simply compiling them will enough.

Quote:

If they can get rid of the code bloat

Quote:

I feel like I need metaprogramming a lot

Quote:

I often can't afford it.

Quote:

The best I can do right now is C++17

typedef channel_traits<channel_name::R, channel_kind::color, uint8_t, 5> red_5bit_color_channel_t;
typedef channel_traits<channel_name::G, channel_kind::color, uint8_t, 6> green_6bit_color_channel_t;
typedef channel_traits<channel_name::B, channel_kind::color, uint8_t, 5> blue_5bit_color_channel_t;
typedef pixel<uint16_t, color_model::rgb, false, red_5bit_color_channel_t, green_6bit_color_channel_t, red_5bit_color_channel_t> rgb565be_t;
rgb565be_t p;

constexpr static const int index = 1;

using ch = rgb565be_t::get_channel<index>;
printf("index: %llu ",(unsigned long long)ch::index);
printf("name: %s, ",ch::name);
printf("type: %s, ",to_string(ch::kind));
printf("int-type size: %llu, ",(unsigned long long)sizeof(ch::int_type));
printf("min: %llu, ",(unsigned long long)ch::min);
printf("max: %llu, ",(unsigned long long)ch::max);
printf("bit-depth: %llu, ",(unsigned long long)ch::bit_depth);
printf("bits_to_left: %llu, ",(unsigned long long)ch::bits_to_left);
printf("bits_to_right: %llu, ",(unsigned long long)ch::bits_to_right);
printf("mask: %llx, ",(unsigned long long)ch::mask);
printf("pixel_mask: %llx\r\n",(unsigned long long)ch::pixel_mask);

index: 1 name: G, type: color, int-type size: 1, min: 0, max: 63, bit-depth: 6, bits_to_left: 5, bits_to_right: 5, mask: 3f, pixel_mask: 7e0

.LC0:
        .string "index: %llu "
.LC1:
        .string "G"
.LC2:
        .string "name: %s, "
.LC3:
        .string "color"
.LC4:
        .string "type: %s, "
.LC5:
        .string "int-type size: %llu, "
.LC6:
        .string "min: %llu, "
.LC7:
        .string "max: %llu, "
.LC8:
        .string "bit-depth: %llu, "
.LC9:
        .string "bits_to_left: %llu, "
.LC10:
        .string "bits_to_right: %llu, "
.LC11:
        .string "mask: %llx, "
.LC12:
        .string "pixel_mask: %llx\r\n"
main:
        push    rax
        mov     esi, 1
        mov     edi, OFFSET FLAT:.LC0
        xor     eax, eax
        call    printf
        mov     esi, OFFSET FLAT:.LC1
        mov     edi, OFFSET FLAT:.LC2
        xor     eax, eax
        call    printf
        mov     esi, OFFSET FLAT:.LC3
        mov     edi, OFFSET FLAT:.LC4
        xor     eax, eax
        call    printf
        mov     esi, 1
        mov     edi, OFFSET FLAT:.LC5
        xor     eax, eax
        call    printf
        xor     esi, esi
        mov     edi, OFFSET FLAT:.LC6
        xor     eax, eax
        call    printf
        mov     esi, 63
        mov     edi, OFFSET FLAT:.LC7
        xor     eax, eax
        call    printf
        mov     esi, 6
        mov     edi, OFFSET FLAT:.LC8
        xor     eax, eax
        call    printf
        mov     esi, 5
        mov     edi, OFFSET FLAT:.LC9
        xor     eax, eax
        call    printf
        mov     esi, 5
        mov     edi, OFFSET FLAT:.LC10
        xor     eax, eax
        call    printf
        mov     esi, 63
        mov     edi, OFFSET FLAT:.LC11
        xor     eax, eax
        call    printf
        mov     esi, 2016
        mov     edi, OFFSET FLAT:.LC12
        xor     eax, eax
        call    printf
        xor     eax, eax
        pop     rdx
        ret

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