Qfyilyi

I'm currently refactoring legacy code, and I stumbled upon this strange node of a linked list

#define CACHE_LINE 128



struct Node {

public:

    intptr_t value;

    Node *next;

    Node *prev;

    bool dummy;

private:

    // Avoid false sharing

    unsigned char padding[CACHE_LINE - sizeof(intptr_t) - 2 * sizeof(Node *) - sizeof(bool)];

};

Assuming that the cache line of the system I work on is 32 bytes wide, that means this object will take up to 4 cache lines (with 32 bytes cache lines). And 3 of them will be completely empty.

This linked list is a part of a lock free queue. I have not determined yet how many producers and how many consumers are using it. From this other post, the answer states the following :

A clarification: for negative consequences at least some accesses to "falsely shared" variables should be writes. If writes are rare, performance impact of false sharing is rather negligible; the more writes (and so cache line invalidate messages) the worse performance.

My question is the following : what degrades the most my performances? False-sharing on this little object, or the fact that a quarter of my cache will be filled with padding ?

Live representation of the memory layout on Compiler Explorer