Thread locals api wrapper

[awsdert]

When looking for the linux equivalents of TlsAlloc etc I found none, since nobody who uses the library I'm making would want to have to check what operating system they're on I've resorted to a wrapper that mimics it as best it can, wandering what you guys think of it. Can it be made better?

#	ifdef PAW_API_MSW
#		define PAWTLS
#		define PAWTLS_API_BASED
#	elif (__GNUC__)
#		define PAWTLS __thread
#	elif defined( _MSC )
#		define PAWTLS _declspec(thread)
#	elif PAW_STDC >= 202300L
#		include <threads.h>
#		define PAWTLS thread_local
#	elif PAW_STDC >= 201113L
#		define PAWTLS _Thread_local
#	else
#		define PAWTLS
#		define PAWTLS_NO_LOCALS
#	endif

Windows:

PAWAPP_API void*  pawtls_create(void) { return (void*)1; }
PAWAPP_API pawvu  pawtls_newloc( void *tls, pawvu size )
	{ (void)tls; (void)size; return TlsAlloc(); }
PAWAPP_API void   pawtls_remloc( void *tls, pawvu i )
	{ (void)tls; TlsFree(i); }
PAWAPP_API void*  pawtls_getloc( void *tls, pawvu i )
	{ (void)tls; return TlsGetValue(i); }
PAWAPP_API void   pawtls_setloc( void *tls, pawvu i, void *ud )
	{ (void)tls; return TlsSetValue( i, ud ); }
PAWAPP_API void   pawtls_delete( void *tls ) { (void)tls; }

Linux:

typedef struct _pawtls_entry { pawvu size; void *value; } pawtls_entry;
PAWTLS pawbuf pawtls = {0};
PAWAPP_API void*  pawtls_create( void ) { return &pawtls; }
PAWAPP_API pawvu  pawtls_newloc( void *tls, pawvu size )
{
	pawtls_entry *list = pawbuf_gettop(pawtls), *ent = NULL;
	pawvu i = 0, len = pawtls.len;
	(void)tls;
	if ( !size )
		return PAWTLS_NO_INDICES;
	if ( !list )
	{
		pawtls = pawbuf_newmax( sizeof(pawtls_entry), PAWCD_WIDTH );
		ent = pawbuf_gettop(pawtls);
		if ( !ent )
			return PAWTLS_NO_INDICES;
		ent->size = size;
		return 0;
	}
	for ( ; i < len; ++i )
	{
		ent = list + i;
		if ( ent->size )
			continue;
		ent->size;
		return i;
	}
	list = pawbuf_fitmax( &pawtls, len * 2 );
	if ( !list )
		return PAWTLS_NO_INDICES;
	ent = list + len;
	ent->size = size;
	pawtls.len++;
	return len;
}
PAWAPP_API void   pawtls_remloc( void *tls, pawvu i )
{
	pawtls_entry *ent = pawbuf_offset( pawtls, i );
	(void)tls;
	if ( !ent )
		return;
	ent->size = 0;
	ent->value = NULL;
}
PAWAPP_API void*  pawtls_getloc( void *tls, pawvu i )
{
	pawtls_entry *ent = pawbuf_offset(pawtls,i);
	return ent ? ent->value : NULL;
}
PAWAPP_API void   pawtls_setloc( void *tls, pawvu i, void *ud )
{
	pawtls_entry *ent = pawbuf_offset( pawtls, i );
	(void)tls;
	if ( ent )
		ent->value = ud;
}
PAWAPP_API void   pawtls_delete(void *tls)
	{ (void)tls; pawbuf_expire(&pawtls); }

[awsdert]

Changed my mind about the wrapper after thinking of a better solution, just ignore tlsalloc altogether...unless I need it specifically for declaring the buffer a thread local.

typedef struct _pawtls_ent { pawexe tid; pawmem mem; } pawtls_ent;
typedef struct _pawtls_buf { pawvu size; pawvu *addr; pawbuf buff; } pawtls_buf;
PAWTLS pawbuf pawtls = {0};
#			ifdef PAWTLS_IS_GLOBAL
static pawsyn pawtls_syn = BAD_pawsyn;
pawd  pawtls_init(void)
	{ return pawsyn_init(&pawtls_syn,&pawtls,pawtls_class,1); }
PAWAPP_QCK void* pawtls_wait(void) { return pawsyn_wait(&pawtls_syn); }
PAWAPP_QCK void  pawtls_free(void) { pawsyn_free(&pawtls_syn); }
void  pawtls_term(void) { pawsyn_term(&pawtls_syn); }
#			else
pawd  pawtls_init(void) { return 0; }
PAWAPP_QCK void* pawtls_wait(void) { return &pawtls; }
PAWAPP_QCK void  pawtls_free(void) {}
void  pawtls_term(void) { pawbuf_expire(&pawtls); }
#			endif
PAWAPP_QCK pawtls_ent* pawtls_newmem( pawtls_buf *buff )
{
	pawexe tid = pawgetexe();
	pawvu i = 0, len = buff->buff.len;
	pawtls_ent **list = (pawtls_ent**)pawbuf_gettop(buff->buff), *ent = NULL;
	for ( ; i < len; ++i )
	{
		ent = list[i];
		if ( ent && ent->tid == tid )
			return ent;
	}
	ent = pawnew(sizeof(pawtls_ent));
	if ( !ent )
		return PAWERR_OUT_OF_SPACE;
	ent->tid = pawgetexe();
	ent->mem = pawmem_newcap( buff->size, buff->size );
	if ( !pawmem_gettop(ent->mem) )
	{
		pawdel( ent, sizeof(pawtls_ent) );
		return PAWERR_OUT_OF_SPACE;
	}
	for ( i = 0; i < len; ++i )
	{
		if ( !list[i] )
			return (list[i] = ent);
	}
	if ( list )
		list = pawbuf_addlen( &(buff->buff), len );
	else
	{
		buff->buff = pawbuf_newnum( sizeof(void*), PAWCD_WIDTH );
		list = pawbuf_gettop(buff->buff);
	}
	if ( !list )
	{
		pawmem_expire(&(ent->mem));
		pawdel( ent, sizeof(pawtls_ent) );
		return PAWERR_OUT_OF_SPACE;
	}
	return (list[len] = ent);
}
PAWAPP_API pawd pawtls_getloc( void **dest, pawvu *addr, pawvu size )
{
	pawbuf *tls = pawtls_wait();
	pawtls_ent *entry = NULL;
	pawtls_buf *buffs = pawbuf_gettop(*tls), *buff = NULL;
	pawvu i = 0, buffc = tls->len;
	pawd err = 0;
	*dest = NULL;
	if ( !addr || !size )
	{
		pawtls_free();
		return PAWERR_INVALID_DATA;
	}
	if ( !buffs )
	{
		*tls = pawbuf_newlen( sizeof(pawtls_buf), PAWCD_WIDTH );
		buffs = pawbuf_gettop(*tls);
		if ( !buffs )
		{
			err = tls->mem.err;
			pawtls_free();
			return err;
		}
	}
	buffc = tls->len;
	for ( i = *addr; i < buffc; ++i )
	{
		buff = buffs + i;
		if ( buff->addr == addr )
		{
			err = (buff->size == size) ? 0 : PAWERR_INVALID_DATA;
			if ( err )
			{
				pawtls_free();
				return err;
			}
			entry = pawtls_newmem(buff);
			pawtls_free();
			if ( entry )
			{
				*dest = pawmem_gettop(entry->mem);
				return 0;
			}
			return PAWERR_OUT_OF_SPACE;
		}
	}
	for ( i = 0; i < buffc; ++i )
	{
		buff = buffs + i;
		if ( buff->addr )
			continue;
		goto claim_buff;
	}
	buffs = pawbuf_addlen( tls, i );
	if ( !buffs )
	{
		err = tls->mem.err;
		pawtls_free();
		return err;
	}
	buff = buffs + i;
	claim_buff:
	*addr = i;
	buff->addr = addr;
	buff->size = size;
	entry = pawtls_newmem(buff);
	if ( entry )
	{
		pawtls_free();
		*dest = pawmem_gettop(entry->mem);
		return 0;
	}
	buff->addr = NULL;
	buff->size = 0;
	*addr = 0;
	return PAWERR_OUT_OF_SPACE;
}
PAWAPP_API void   pawtls_remloc( pawvu *addr )
{
	pawexe tid = pawgetexe();
	pawbuf *tls = pawtls_wait();
	pawtls_ent *list = NULL, *ent = NULL;
	pawtls_buf *buff = pawbuf_offset( *tls, *addr );
	pawvu i = 0, len = 0;
	if ( !buff || buff->addr != addr )
	{
		pawtls_free();
		return;
	}
	len = pawbuf_getlen(buff->buff);
	for ( ; i < len; ++i )
	{
		ent = list[i];
		if ( ent && ent->tid == tid )
		{
			pawmem_expire(&(ent->mem));
			pawdel( ent, sizeof(pawtls_ent) );
			list[i] = NULL;
			break;
		}
	}
	for ( i = 0; i < len; ++i )
	{
		if ( list[i] )
		{
			pawtls_free();
			return;
		}
	}
	buff->addr = NULL;
	buff->size = NULL;
	pawbuf_expire( &(buff->buff) );
	pawtls_free();
}
PAWAPP_API void   pawtls_remall(void)
{
	// Not yet written, planning to remove all of current thread's pointers from the array, probably make use of my define to cleanup completely when locals are available
}

The basic idea is that can declare global indices normally with:

PAWTLS pawvu global_name = 0;
void* thread( void*ud )
{
	foo_t *thread_ptr = NULL;
	pawd err = pawtls_addloc( (void**)&thread_ptr, &global_name, sizeof(foo_t) );
	if ( err )
		return ud;
	...
	pawtls_remall();
	return ud;
}

The thing about this design is that it's usable even for library functions that cannot/should not pass their indices back, the only thing that is needed is for the critical section to be initialized & destroyed in the main thread, unless someone has a better idea for forcing tls to be available even in strict C89/C99 I'll be going with this.

[adeyblue]

The Linux/posix equivalent of TLSAlloc and friends are pthread_key_create and pthread_get/setspecific

[awsdert]

The Linux/posix equivalent of TLSAlloc and friends are pthread_key_create and pthread_get/setspecific

Thanks, having look at it I think I'll still go with a custom solution, was just about to post an improved version of my existing solution, realised I was taking the long route with buffers when linked lists would be faster, so now I'm using that:

typedef struct _pawtls_ent pawtls_ent;
typedef struct _pawtls_buf pawtls_buf;
struct _pawtls_ent { pawtls_ent *prv, *nxt; pawexe tid; void *data; };
struct _pawtls_buf { pawtls_buf *prv, *nxt; pawvu size; pawvu *addr; pawtls_ent *top; };
PAWTLS pawtls_buf *pawtls = NULL;
#			ifdef PAWTLS_IS_GLOBAL
static pawsyn pawtls_syn = BAD_pawsyn;
pawd  pawtls_init(void)
	{ return pawsyn_init(&pawtls_syn,(void*)&pawtls,pawtls_class,1); }
PAWAPP_QCK pawtls_buf* pawtls_wait(void)
	{ return *((pawtls_buf**)pawsyn_wait(&pawtls_syn)); }
PAWAPP_QCK void  pawtls_free(void) { pawsyn_free(&pawtls_syn); }
void  pawtls_term(void) { pawsyn_term(&pawtls_syn); }
#			else
pawd  pawtls_init(void) { return 0; }
PAWAPP_QCK pawtls_buf* pawtls_wait(void) { return pawtls; }
PAWAPP_QCK void  pawtls_free(void) {}
void  pawtls_term(void) { pawbuf_expire(&pawtls); }
#			endif
static pawtls_ent* pawtls_newmem( pawtls_buf *buff )
{
	pawexe tid = pawgetexe();
	pawtls_ent *prv = buff->top, *ent = prv;
	for ( ; ent; prv = ent, ent = ent->nxt )
	{
		if ( ent->tid == tid )
			return ent;
	}
	ent = pawnew(sizeof(pawtls_ent));
	if ( !ent )
		return PAWERR_OUT_OF_SPACE;
	ent->tid = pawgetexe();
	ent->nxt = buff->top;
	ent->data = pawnew( buff->size );
	if ( !pawmem_gettop(ent->data) )
	{
		pawdel( ent, sizeof(pawtls_ent) );
		return NULL;
	}
	if ( buff->top )
		buff->top->prv = ent;
	buff->top = ent;
	return ent;
}
PAWAPP_API pawd pawtls_getloc( void **dest, pawvu *addr, pawvu size )
{
	pawd err = 0;
	pawtls_ent *entry = NULL;
	pawtls_buf *buffs = pawtls_wait(), *buff = (void*)(*addr);
	*dest = NULL;
	if ( !size )
	{
		pawtls_free();
		return PAWERR_INVALID_DATA;
	}
	if ( buff )
	{
		if ( buff->size != size )
		{
			pawtls_free();
			return PAWERR_INVALID_DATA;
		}
		entry = pawtls_newmem(buff);
		if ( !entry )
			err = PAWERR_OUT_OF_SPACE;
		else
			*dest = entry->data;
		pawtls_free();
		return err;
	}
	buff = pawnew(sizeof(pawtls_buf));
	if ( !buff )
	{
		pawtls_free(buff);
		return PAWERR_OUT_OF_SPACE;
	}
	buff->addr = addr;
	buff->size = size;
	buff->nxt = buffs;
	entry = pawtls_newmem(buff);
	if ( !entry )
	{
		pawtls_free();
		pawdel( buff, sizeof(pawtls_buf) );
		return PAWERR_OUT_OF_SPACE;
	}
	*dest = entry->data;
	if ( buffs )
		buffs->prv = buff;
	pawtls = buff;
	pawtls_free();
	return 0;
}
PAWAPP_API void   pawtls_remloc( pawvu *addr )
{
	pawexe tid = pawgetexe();
	pawtls_ent *prv = NULL, *ent = NULL;
	pawtls_buf *tls = pawtls_wait(), *buff = (void*)(*addr);
	pawvu i = 0, len = 0;
	if ( !buff || buff->addr != addr )
	{
		pawtls_free();
		return;
	}
	prv = ent = buff->top;
	for ( ; ent; prv = ent->nxt )
	{
		if ( ent->tid == tid )
		{
			prv->nxt = ent->nxt;
			if ( ent->nxt )
				ent->nxt->prv = ent->prv;
			if ( buff->top == ent )
				buff->top = ent->nxt;
			break;
		}
	}
	if ( !(buff->top) )
	{
		if ( buff->prv )
			buff->prv->nxt = buff->nxt;
		if ( buff->nxt )
			buff->nxt->prv = buff->prv;
		pawdel(buff);
		*addr = 0;
	}
	pawtls_free();
}
PAWAPP_API void   pawtls_remall(void)
{
	pawtls_buf *buff = pawtls_wait(), temp = {NULL};
	for ( ; buff; buff = temp.nxt )
	{
		temp = *buff;
		pawtls_remloc( buff->addr );
	}
	pawtls_free();
}