Array: Data type and calculation of element size

[adbridge]

1. In struct array_link ,
   shouldn't uint8_t *data;
   be T *data; ?
2. In the init function,
   _element_size = PoolAllocator::align_up(sizeof(T), alignment);
   Shouldn't alignment be calculated from 'alignof(T)' rather than coming in as an init parameter?

[bogdanm]

1. No. As the comments in Array.h show, data doesn't actually hold T elements, but rather T elements plus a link to the next part of the array.
2. There are legitimate reasons to force a certain alignment. That said, the alignment can default to alignof(T)

[adbridge]

1. But the data pointer always points to the start of the data itself which will be of type T* , does it matter that the array link structure itself is tagged on to the end? It would also simplify the get_element_address() function as you would no longer need to do the calculations.
2. That would certainly be safe than defaulting to MBED_UTIL_POOL_ALLOC_DEFAULT_ALIGN ?

[bogdanm]

1. Yes, it does matter. The point is that the storage and the link to the next part are allocated in a single contigous memory region, which reduces fragmentation. A pointer of type T would hide this and might lead to incorrect assumptions about the code. Even if this wasn't the case, this is an implementation detail that doesn't affect the functionality of the code, so I fail to see why this is an issue.
2. Certainly. alignof is a C++11 construct, so it wasn't available when this code was originally written. We can change it now.

[adbridge]

How does a pointer of type T hide the structure of your memory block anymore than a pointer of type uint8_t * hides the fact that your data is of type T ? That is what the documentation is for anyway . Agreed 1 might actually fall into the realm of optimisation rather than issue.

The standard way I have seen of implementing this kind of storage is to have your control structure at the top of the memory block with a format :

struct array_link {
    unsigned first_index;
    array_link *prev;
    T data[1];
}

Then when creating the storage you malloc , sizeof(array_link) + ( (num_elements -1) * sizeof(T))
Then you can just index data from 0 to num_elements - 1 directly by allowing the data array to overflow into the reserved memory block . Which means you don't need to do the pointer arithmetic and casting every time you push_back an element.

[ciarmcom]

ARM Internal Ref: IOTSFW-2001