How can I initialize similar structs with the same function? - c

Question

I have some structs that start with a void *buffer and the next members can be of different types:
struct A {
void *buffer;
type_x *x;
type_y *y;
};
struct B {
void *buffer;
type_w *w;
type_y *y;
type_z *z;
};
The buffer from struct A will store n elements of type type_x, followed by n elements of type_y. The other members, type_x *x and type_y *y, will point to those arrays, respectively. Analogous for struct B.
What I'm currently doing is something like this:
void allocate(struct B **b, unsigned int n) {
(*b)->buffer = calloc(n * (sizeof(type_w) + sizeof(type_y) + sizeof(type_z));
(*b)->w = (type_w *) (*b)->buffer;
(*b)->y = (type_y *) ((*b)->w + n);
(*b)->z = (type_z *) ((*b)->y + n);
}
Is there any way to create a function to achieve this? The function should receive as arguments a pointer to one of these structs (void *s) and an int, like this:
void allocate(void *s, unsigned int n) {
// MAGIC
}
Some other options I've considered:
Create void allocate(void *buffer, int n, ...) and give it pointers to the pointers of the struct. The problem with this is that I have to give it void * pointers, so I would have to give it the size of every type as well.
Create void *create_struct(StructType type) (where StructType is an enum) but I would have to code the case for every struct anyway and I want to be able to define new structs and not have to write aditional code.
I'm trying to do this as I will have many structs, and because the allocate function does basically the same thing for every struct I thought there may be a "cleaner" way to do it.
Also, I know that I can just remove the buffer and allocate memory directly to all the members, but I want to do it this way so data is stored contiguously.

Answer 1

There is no generic way to do this that doesn't play fast and loose with type safety. This means, technically, a truly generic solution will result in undefined behavior. If I was forced to implement something like this, I would have to assume I could treat the incoming structure pointer as an array of pointers. And the size of each type would need to be passed in. Ignoring alignment issues, some untested code:
void allocate(void *sp, size_t n, ... /* terminate with 0 */) {
void **sv = sp;
size_t arg, total = 0;
size_t args = 0;
va_list ap;
va_start(ap, n);
while ((arg = va_arg(ap, size_t)) != 0) {
total += arg;
++args;
}
va_end(ap);
*sv = calloc(...);
sv[1] = sv[0];
va_start(ap, n);
while (--args > 0) {
++sv;
sv[1] = (char *)sv[0] + va_arg(ap, size_t);
}
va_end(ap);
}
allocate(a, n, sizeof(type_x), sizeof(type_y), (size_t)0);
allocate(b, n, sizeof(type_w), sizeof(type_y), sizeof(type_z), (size_t)0);
Clearly hacky and ugly.
The better solution should really be to create a separate allocator function for each type. However, you can create a macro to aid in the automatic generation of the allocator. More untested code follows:
#define CREATE_ALLOCATOR(Type, X_Fields) \
void allocate_##Type (struct Type *sp, size_t n) { \
_Pragma("pop_macro(\"X\")") \
size_t total = 0 \
X_Fields \
; \
void *p; \
sp->buffer = calloc(sizeof(*sp) + total); \
p = sp->buffer; \
_Pragma("pop_macro(\"X\")") \
X_Fields \
; \
}
#include "create_allocator_helper.h"
CREATE_ALLOCATOR(A, X(x) X(y))
#include "create_allocator_helper.h"
CREATE_ALLOCATOR(B, X(w) X(y) X(z))
Where the helper header file defines and pushes some X macro definitions used by the CREATE_ALLOCATOR macro:
#ifdef X
#undef X
#endif
#define X(A) ; sp->A = p; p = sp->A + n
#pragma push_macro("X")
#undef X
#define X(A) + sizeof(sp->A)
#pragma push_macro("X")
#undef X

Answer 2

If you know the set of possible ns at compile time, you can let each (member set)/(array size) combination be its own type, and use convenience macros to refer to the correct ones.
#include <stddef.h>
/*
We put a type marker at the beginning of each struct. There won't be padding before the first member, and all the types
start with a struct Type, so we can do `(struct Type*)&unknown_structure` and be guaranteed to have a valid object that
tells us what type the rest of it is.
In practice, I'd probably use X-Macros to generate an enum containing all the types instead of using strings, to
make comparison faster
*/
struct Type { char *type; size_t n; };
/* We define what types of arrays each structure contains. Since the struct contains the arrays themselves
instead of pointers to them, the memory will be contiguous, +/- a bit of padding. */
#define DECL_A(N) struct A_##N { struct Type type; char x[N]; double y[N]; }
#define DECL_B(N) struct B_##N { struct Type type; size_t n; int x[N]; float y[N]; char z[N]; }
/*
Declare a struct and initialize the type and n members. This one just
declares a local variable, but we could make a malloc version easily enough.
*/
#define CREATE_STRUCT(NAME, TYPE, N) struct TYPE##_##N NAME = { .type = { #TYPE, N} }
/* We declare all struct type/size combinations we'll use */
DECL_A(42);
DECL_A(100);
DECL_B(30);
int main(void) {
int i;
CREATE_STRUCT(foo, A, 42);
CREATE_STRUCT(bar, A, 100);
CREATE_STRUCT(baz, B, 30);
return 0;
}

Answer 3

Here's an alternative that doesn't require n to be known at compile time.
Note that I am not completely sure about the legality of this, but I'm
reasonably sure it's valid. The key idea here is that if p points to a
properly aligned memory block for type T, then ((char*)p) + sizeof(T) * N must also point
to properly aligned memory as long as it falls within an allocated block.
As long as that's true, I'm pretty sure this must necessarily be legal, since the union
of buffer and Alignment_Hack guarantees that buffer[0] is aligned properly for all types.
Even if it's legal, it's still a bit of a hack, so I'm not entirely sure I'd recommend it, but it's a potential option.
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
/* This MUST contain all types that might be stored in the arrays */
union Alignment_Hack {
short hd;
int d;
char c;
float hf;
double f;
};
/* This struct is used for *all* structures. The structure-specific details get specified later */
struct Variable_Structure {
size_t num_arrays;
void **arrays;
union {
union Alignment_Hack *hack;
char *buffer;
} u; //u.buffer[0] is guaranteed to be properly aligned for anything in the union
};
//Here's where the details for a specific struct (struct A {short x; double y; int z; }) are specified.
size_t sizes_A[] = { sizeof(short), sizeof(double), sizeof(int) };
void create_structure(struct Variable_Structure *p, const size_t array_count, size_t *sizes, unsigned nvars) {
size_t offsets[nvars];//in bytes (NOTE: requires C99)
unsigned i;
offsets[0] = 0;
for (i = 1; i < nvars; i++) {
//offsets[i] must be an even multiple of sizes[i] and must also be past the end of the last array
size_t min = offsets[i - 1] + sizes[i - 1] * array_count;
size_t mod = min % sizes[i];
//offsets[i] = min_p such that p >= min and p % sizes[i] == 0
offsets[i] = (min - mod) + (mod ? sizes[i] : 0);// (min - mod) and (min - mod + sizes[i]) are the two possible starting points
/* Visualization of the transition from TYPE_A[] to TYPE_B[], showing where everything's pointing:
min (end of TYPE_A array)
V
... | TYPE_A | TYPE_A | TYPE_A |
... | TYPE_B | TYPE_B | TYPE_B | TYPE_B |
^ ^
min - mod (min - mod) + sizes[i] */
assert(offsets[i] >= min);//doesn't overlap previous array
assert(offsets[i] <= min + sizes[i]);//doesn't include more padding than necessary
assert(0 == offsets[i] % sizes[i]);//alignment correct
}
size_t bufsiz = offsets[nvars - 1] + sizes[nvars - 1] * array_count;
//Skipping error checking for brevity
p->num_arrays = nvars;
p->u.buffer = malloc(bufsiz);
p->arrays = malloc(sizeof(void*) * nvars);
for (i = 0; i < nvars; i++) {
p->arrays[i] = p->u.buffer + offsets[i];
}
}
void free_structure(struct Variable_Structure *p) {
free(p->arrays);
free(p->u.buffer);
}
int main(void) {
struct Variable_Structure a;
size_t n = 42;
create_structure(&a, n, sizes_A, sizeof(sizes_A)/sizeof(*sizes_A));
unsigned i;
for (i = 0; i < n; i++) {
//We could always set up some macros or something so we could say, e.g., A(x, i) instead of ((short*)a.arrays[0])[i]
((short*)a.arrays[0])[i] = i;
((double*)a.arrays[1])[i] = i;
((int*)a.arrays[2])[i] = i;
printf("%hd %f %d\n",
((short*)a.arrays[0])[i],
((double*)a.arrays[1])[i],
((int*)a.arrays[2])[i]);
}
printf("SIZES: %zu %zu %zu\n", sizeof(short), sizeof(double), sizeof(int));
printf("OFFSETS: %p %p %p\n", a.arrays[0], a.arrays[1], a.arrays[2]);
free_structure(&a);
return 0;
}