• @jsomae@lemmy.ml
    link
    fedilink
    24
    edit-2
    14 days ago

    Use bit-fields:

    struct {
      bool a : 1;
      bool b : 1;
      bool c : 1;
      //...
    };
    

    Edit: careful not to use a 1-bit signed int, since the only values are 0 and -1, not 0 and 1. This tripped me up once.

    • In a world where a bigger memory chip is more expensive by only a few cents where this would be most useful, is this feature still relevant?

      • @homura1650@lemm.ee
        link
        fedilink
        16 hours ago

        I’ve used it a fair amount for memory mapped IO where the hardware defined bitfields. It is also useful when you have a data format with bitfields. I’d say it is also useful when your data does not respect byte boundaries, but the only time I’ve run into that involved the bit order being “backwards”, which means that I still had to bittwidle things back together.

        From a performance perspective, a cache line is only 64 bytes. Space in registers, low level memory caches, and memory throughout are all limited as well.

      • @kora@sh.itjust.works
        link
        fedilink
        5
        edit-2
        14 days ago

        Yes, firmware running on bare metal requires good resource management. My current development board processor contains 512KB SRAM. That’s equivalent to half of the size of an average PDF.

      • @jsomae@lemmy.ml
        link
        fedilink
        2
        edit-2
        14 days ago

        Yes, because cache optimization is still important. Also useful to keep the size of packets down, to reduce the size of file formats, and anywhere that you use hundreds of thousands of instances of the struct.

        • For the packet size and fils format issues, it seems like this language feature would be less reliable than bit shifting or masking, given that different implementations may store the bits in a different order or not compactly