struct chan_t { pthread_mutex_t* m_mu;... }
And initialize it like so: pthread_mutex_t* mu =
(pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mu, NULL);
chan->m_mu = mu;
eps's suggestion is to put the mutex directly in the struct: struct chan_t { pthread_mutex_t m_mu;... }
and initialize it by passing its address to pthread_mutex_init: pthread_mutex_init(&chan->m_mu, NULL);
chan->m_mu = mu;
that saves some mallocs and dereferences. If you are new to C, the notion of taking the address of fields in a struct may be unnerving, but you get used to it :)Valgrind is your friend :)
http://valgrind.org/docs/manual/quick-start.html#quick-start...
struct foo
{
pthread_mutex_t bar;
...
};Just allocate a pointer on the stack, read into it, and then assign the value into the provided space:
void *msg_ptr;
read(..., &msg_ptr, sizeof msg_ptr);
*data = msg_ptr;Also worth noting, he really shouldn't be using '_t' since it's reserved by the standard.
Not to say that it wouldn't work, just that it isn't really necessary - casting a pointer to a structure to a pointer to its first member (and back) is perfectly portable. Perhaps even idiomatic. (Though the casts in that gist seem to be backwards?)
That said, it is 'portable' since in general no compilers reorder the struct members, but container_of is guaranteed to work, works for multiple members in a struct exactly the same way, and will reduce to a simple cast when your offsetof is zero so there isn't any performance penalty in situations like this. IMO there's no reason not to use container_of in this case.
To quote the relevant section (C99 6.7.2.1.13, same wording present in C89):
Within a structure object, the non-bit-field members and the units in which bit-fields reside have addresses that increase in the order in which they are declared. A pointer to a structure object, suitably converted, points to its initial member (or if that member is a bit-field, then to the unit in which it resides), and vice versa. There may be unnamed padding within a structure object, but not at its beginning.
I'll repeat that I consider direct casts to be somewhat idiomatic. Macros are more traditional for offset members.
Or put differently, direct casting comes with an assumption, while container_of doesn't. The fewer obscure assumptions are there in the code, the better. I think we can all agree on that :)
Why chan's mutexes and pcond are malloc'ed and not included in chan's struct? They are also not freed when channel is disposed, unless I'm missing something. Mutexes are also not destroyed when buffered chan is disposed, but they are created for it.
(Edit)
Also, my biggest nitpick would be that chan_t structure should really not be in chan.h header since it's meant to be transparent to the app and the API operates exclusively with pointers to chan_t. Then, if it is made private (read - internal to the implementation), then you can divorce buffered and unbuffered channels into two separate structs, allocate required one and then multiplex between them in calls that treat buffered and unbuffered channels differently. I.e.
or better yet, just include a handful of function pointers into chan_t for each of the API methods that need more than the shared part of chan_t struct, initialize them on allocation and put type-specific code in these functions. It will make for a more compact, concise and localized code.(Edit 2)
Here's what I mean with function pointers - https://gist.github.com/anonymous/5f97d8db71776b188820 - basically poor man's inheritance and virtual methods :)