What is the memory overhead per LED "cloned," pointed to, via CRGBSets?
I've looked for an answer, but could only uncover that CRGBSets create pointers to the parts/ranges of the original CRGB array of LEDs. Nothing on memory overhead.
If you look in pixelset.h, you'll see that CRGBSet is just a typedef for CPixelView:
typedef CPixelView<CRGB> CRGBSet;
Looking in the same file at the beginning of the CPixelView class definition shows:
template<class PIXEL_TYPE>
class CPixelView {
public:
const int8_t dir; ///< direction of the LED data, either 1 or -1. Determines how the pointer is incremented.
const int len; ///< length of the LED data, in PIXEL_TYPE units. More accurately, it's the distance from
/// the start of the CPixelView::leds array to the end of the set (CPixelView::end_pos)
PIXEL_TYPE * const leds; ///< pointer to the LED data
PIXEL_TYPE * const end_pos; ///< pointer to the end position of the LED data
Those appear to be the class's only data members. So, I'd say the memory overhead is independent of the number of leads in the referenced CRGB array.
I found, with your "pointers" clue, that pointers can, on a 32-bit PC, take 4 bytes--8 bytes on a 64 bit machine. However, that seems to be per variable/array, not per the size of the variable/array.
Then I just discovered the Arduino IDE shows memory usage on each compile--DOH! When I ran tests, I found each CRGBSet, no matter it's size, only used 7 bytes. I used 4 CRGBSets of varying sizes, and each time memory usage only went up by only 7 bytes.
So, it seems that CRGBSets only take up 7 bytes per set.
It appears you're testing that on an 8-bit AVR processor. The result would have be different on a 32-bit processor like ARM or ESP32/8266. Of course, it would been faster and more reliable just ask the compiler:
Serial.println(sizeof(CRGBSet));
Either way, the answer would not include any dynamically-allocated memory. But, if you continue looking at the source code for the CPixelView class, you'll see it doesn't use any.