Thread: Is it possible to set/get user data to HANDLE/pthread_t?

Every attempt to find the information on the net just keeps coming up with irrelevant results around pthread_create() instead of say pthread_get_ud( thread )/pthread_set_ud( thread, ud ), I would prefer being able to get the final argument that gets passed onto the thread but no matter what I search it doesn't seem to be a thing despite it being such an obvious feature to need, just like windows, gc objects & others need.

Edit: To be clear it's these sort of actions I'd like to do something similar to:

Code:

glfwSetWindowUserPointer( Win->handle, Win );
...
void	onClosed( GLFWwindow *handle )
{
	pawWIN Win = glfwGetWindowUserPointer( handle );
	if ( Win->onClosedCB )
		Win->onClosedCB( Win );
}

Where all I have is the source api's reference to begin with

So far the only thing I've been able to come up with is this:

Code:

typedef struct _PAW_APPOBJ
{
	pawd perm;
	pawjd pid;
} PAW_APPOBJ, *pawPROC;

#define BAD_PAW_APPOBJ { 0, -1 }

typedef void* (*pawrun_cb)( void *ud );
typedef struct _PAW_RUNOBJ
{
	pawd perm;
	pawjd tid;
	pawc _tag[bitsof(pawjd)];
	void *ud;
	pawrun_cb initCB;
	pthread_t thread;
} PAW_RUNOBJ, *pawEXEC;

typedef const PAW_APPOBJ PAWPROC;
typedef const PAW_APPOBJ PAWPROC;

extern pawjd _pawthis_pid;
PAW_APPOBJ paw_proc = BAD_PAW_APPOBJ;

PAW_API pawjd	pawthis_tid() { return gettid(); }
PAW_API pawjd	pawthis_pid() { return _pawthis_pid; }
PAW_API pawapp	pawthis_app()
{
	paw_proc.pid = _pawthis_pid;
	paw_proc.perm = 0700;
	return &paw_proc;
}
PAW_API pawrun	pawthis_run()
{
	pawju addr = 0;
	pawEXEC exec = NULL;
	pawlsu lsu = BAD_pawlsu;
	pthread_t thread = pthread_self();
	pawc tag[bitsof(pawju)], ignored[bitsof(pawju)];
	paw_set( tag, 0, bitsof(pawju) );
	pthread_tag_np( ignored, tag );
	paws2pawls( lsu->str, PAWLSU_MAX, tag, paws_len(tag) );
	pawlsu2pawju( &addr, &lsu, PAW_BASE16X );
	exec = (pawEXEC)addr;
	if ( exec )
		return exec;
	pthread_tag( tag, ignored );
	return NULL;
}
void* pawrun_initCB( void *ud )
{
	pawEXEC exec = UD;
	pawlsu lsu = BAD_pawlsu;
	pawc ignored_tag[bitsof(pawju)];
	exec->tid = pawthis_tid();
	pawju2pawlsu( &lsu, (pawvu)ud, PAW_BASE16X );
	pawls2paws( exec->_tag, bitsof(pawju) - 1, lsu->str, lsu->len );
	pthread_tag_np( exec->_tag, ignored_tag );
	exec->initCB( exec->ud );
	return ud;
}
PAW_API pawrun pawrun_create( void *attr, void *ud, pawrun_cb initCB )
{
	if ( _pawthis_pid >= 0 )
	{
		pawEXEC exec = pawgetUD( sizeof(PAW_RUNOBJ) );
		if ( exec )
		{
			pawd did = 0;

			exec->pid = _pawthis_pid;
			exec->initCB = initCB;
			exec->ud = ud;

			did = pthread_create
			(
				&(exec->thread), NULL,
				pawrun_initCB, exec
			);
			if ( did == 0 )
				return thread;
			pawdel(exec);
		}
	}
	errno = ENODATA;
	return NULL;
}
#endif

Not ideal but all I got for now, still gotta investigate what I have available in windows, as for the _pawthis_pid, turns out getpid() changes value with gettid() so calling it is pointless in threads, instead I capture it at the start, I also use it to detect if the globals have yet to be initialised

Realised there was a way to achieve what I originally wanted:

Code:

#else
#include <sys/syscall.h>
typedef struct _PAW_APPOBJ
{
	pawd perm;
	pawjd pid;
} PAW_APPOBJ, *pawPROC;

#define BAD_PAW_APPOBJ { 0, -1 }

typedef void* (*pawrun_cb)( void *ud );
typedef struct _PAW_RUNOBJ
{
	pawjd tid;
	void *ud;
	pawrun_cb initCB;
} PAW_RUNOBJ, *pawEXEC;

#define BAD_PAW_RUNOBJ { -1, -1, NULL, NULL }

typedef const PAW_APPOBJ PAWPROC;
typedef const PAW_APPOBJ PAWPROC;

extern pawjd _pawthis_pid;
PAW_APPOBJ paw_proc = BAD_PAW_APPOBJ;

PAW_API pawjd	pawthis_tid()
{
#ifdef _GNU_SOURCE
	return gettid();
#elif defined(__linux__)
	return syscall(SYS_gettid);
#elif defined(__FreeBSD__)
	long tid;
	thr_self(&tid);
	return tid;
#elif defined(__NetBSD__)
	return _lwp_self();
#elif defined(__OpenBSD__)
	return getthrid();
#else
	return getpid();
#endif
}
PAW_API pawjd	pawthis_pid() { return _pawthis_pid; }
PAW_API pawapp	pawthis_app()
{
	paw_proc.pid = _pawthis_pid;
	paw_proc.perm = 0700;
	return &paw_proc;
}
PAW_API pawrun	pawthis_run() { return pawthis_tid(); }
void* pawrun_initCB( void *ud )
{
	pawEXEC exec = ud;
	PAW_RUNOBJ safe = *exec;
	exec->tid = pawthis_tid();
	safe.initCB( safe.ud );
	return NULL;
}
PAW_API pawrun pawrun_create( void *attr, void *ud, pawrun_cb initCB )
{
	if ( _pawthis_pid >= 0 )
	{
		pawd did = -1;
		pthread_t thread;
		PAW_RUNOBJ exec = BAD_PAW_RUNOBJ;
		exec->initCB = initCB;
		exec->ud = ud;
		if ( pthread_create( &thread, NULL, pawrun_initCB, &exec ) )
			return BAD_pawrun;
		while ( exec.tid < 0 )
			paw_yield();
		return exec.tid;
	}
	errno = ENODATA;
	return BAD_pawrun;
}
#endif

I wanted a portable interface for working with raw system stuff, I would then design my objects around that, open to ideas on how to return a user pointer from both win32 & linux, pthreads I can probably get away with just returning safe.ud but win32 returns a DWORD, without some means of associating a pointer with the thread I don't see a way to extract the pointer from the DWORD, best I can come up with would involve a hidden buffer & mutex, that also means I would have to ensure some way of termination on an exit() call which may be possible with what I have but I don't want to bank on it

If somebody finds there way here looking for an answer to this problem, and is after a simple but non-portable solution. C11 standardard includes __Threadlocal

Code:

/////////////////////////////////////////////
// Ideally put these in their own file,
// and create a .h file for the functions
////////////////////////////////////////////
static __thread char *tls_storage;


char *get_thread_local(void) {
    return tls_storage;
}


char *set_thread_local(char *new_val) {
    char *old_val = tls_storage;
    tls_storage = new_val;
    return old_val;
}

Part of the ethos of threads is that they are separate threads of program execution in a shared memory space (but with their own stack space). Any use of thread-local storage chips away at this, and I feel should be avoided if at all possible.

Oh, this snippet may help, as it switches to the C11 standard's "__Thread_local" attribute.

Code:

/* gcc doesn't know _Thread_local from C11 yet */
#ifdef __GNUC__
# define thread_local __thread
#elif __STDC_VERSION__ >= 201112L
# define thread_local _Thread_local
#else
# error Don't know how to define thread_local
#endif

Originally Posted by hamster_nz

If somebody finds there way here looking for an answer to this problem, and is after a simple but non-portable solution. C11 standardard includes __Threadlocal

Code:

/////////////////////////////////////////////
// Ideally put these in their own file,
// and create a .h file for the functions
////////////////////////////////////////////
static __thread char *tls_storage;


char *get_thread_local(void) {
    return tls_storage;
}


char *set_thread_local(char *new_val) {
    char *old_val = tls_storage;
    tls_storage = new_val;
    return old_val;
}

Part of the ethos of threads is that they are separate threads of program execution in a shared memory space (but with their own stack space). Any use of thread-local storage chips away at this, and I feel should be avoided if at all possible.

Oh, this snippet may help, as it switches to the C11 standard's "__Thread_local" attribute.

Code:

/* gcc doesn't know _Thread_local from C11 yet */
#ifdef __GNUC__
# define thread_local __thread
#elif __STDC_VERSION__ >= 201112L
# define thread_local _Thread_local
#else
# error Don't know how to define thread_local
#endif

I wish these forums had a like button for posts, this woulda gotten a big thumbs up from me, so far the tag & name options are the only means I can find for a quick pointer system, the slower alternatives are either buffers or environment variables

btw I didn't mean thread local, I mean a pointer created for the thread prior to the thread itself, it's contents are supposed to be outside the thread's local storage

Originally Posted by hamster_nz

My working example does exactly that... saving the vargp value for later use.

Code:

////////////////////////////////////////////
// Example of using it
////////////////////////////////////////////
void thread_close(void) {
    printf("My thread local data is %s\n", get_thread_local());
}


void *myThreadFunc(void *vargp)
{
    set_thread_local(vargp); // Save it away for later
    sleep(1);
    thread_close();
    return NULL;
}


////////////////////////////////////////////
// main() starting two threads
////////////////////////////////////////////
int main()
{
    pthread_t thread_id1, thread_id2;
    printf("Before Thread\n");
    pthread_create(&thread_id1, NULL, myThreadFunc, "Thread1 data");
    pthread_create(&thread_id2, NULL, myThreadFunc, "Different data for Thread2");
    pthread_join(thread_id1, NULL);
    pthread_join(thread_id2, NULL);
    printf("After Thread\n");
    exit(0);
}

Code:

$ /tmp/a
Before Thread
My thread local data is Different data for Thread2
My thread local data is Thread1 data
After Thread

My misunderstanding then

Just to expand a bit on hamster_nz's suggestion, after learning of that extension I went and did a bit of research, for now I have this:

Code:

/* Thanks to hamster_nz for identifying this to me :)
 * https://cboard.cprogramming.com/c-programming/181257-possible-set-get-user-data-handle-pthread_t.html
 * */
#ifdef __GNUC__
#define paw_thread_local __thread
#elif defined( _MSC )
#define paw_thread_local _declspec(thread)
#elseif PAW_STDC >= 202300L
#define paw_thread_local thread_local
#else /*if PAW_STDC >= 201113L*/
#define paw_thread_local _Thread_local
#endif

thread_local pawRUN _pawRUN = NULL;

It's actually supposed to have a #ifdef guard for paw_thread_local but I'll deal with that later, as for the fallback I decided that I won't both with a buffer for now and instead just rely on the environment variables to extract the pointer, here's a snippet from my current code, haven't tested it but I know the stringify/numerify functions work just fine so in theory no issue:

Code:

void* pawRUN_initCB( void *ud )
{
	pawRUN Run = ud;
	_pawRUN = Run;
	Run->tid = pawthis_tid();
	if ( Run->initCB )
	{
		pawsu *key = &(Run->env_key), *val = &(Run->env_val);
		pawju2pawsu( key, Run->tid, PAWS_BASE10 );
		pawju2pawsu( val, (pawvu)Run, PAWS_BASE16X );
		paw_ins( key->txt, key->len, PAWRUN_PFX, sizeof(PAWRUN_PFX) - 1 );
		setenv( key->txt, val->txt, 1 );
		pawgc_decl_ud( Run->id, Run );
		pawgc_decl_voidCB( Run->id, pawRUN_voidCB );
		Run->initCB( Run->id, Run->ud );
		unsetenv( key->txt );
	}
	return NULL;
}
static pthread_t pawrun_pthread( pawrun run )
{
	paws txt = NULL;
	pawsu key = BAD_pawsu, val = BAD_pawsu;
	pawju addr = 0;
	pawRUN Run = NULL;
	pawju2pawsu( &key, run, PAWS_BASE16X );
	/* We get at least 48 remaining characters to work with so no fear of
	 * buffer overruns */
	paw_ins( key.txt, key.len, PAWRUN_PFX, sizeof(PAWRUN_PFX)-1 );
	txt = getenv( key.txt );
	paw_cpy( val.txt, txt, paws_len(txt) );
	pawsu2pawju( &addr, &val, PAWS_BASE16X );
	Run = (void*)addr;
	return Run->thread;
}

Just on the off chance the environment decides to use the text pointers as is I attached them to the thread object directly, I just gotta get round to clearing the variable prior to deleting the object.

I just want to show you why people here aren't able to offer you much useful advice. It might just be my failings.

I've gone through the last code snipped, and replaced everything that has no meaning to me with XXXXs, even after a few attempts to Google things (e.g. pawsu2pawju - Google Search )

Code:

void* pawRUN_initCB( void *ud )
{
    XXXXXX Run = ud;
    XXXXXXX = Run;
    Run->tid = XXXXXXXXXXXX();
    if ( Run->initCB )
    {
        XXXXX *key = &(Run->env_key), *val = &(Run->env_val);
        XXXXXXXXXXX( key, Run->tid, XXXXXXXXXX );
        XXXXXXXXXXX( val, (XXXXX)Run, XXXXXXXXXXXX );
        XXXXXXX( key->txt, key->len, XXXXXXXXXX, sizeof(XXXXXXXXXX) - 1 );
        setenv( key->txt, val->txt, 1 );
        XXXXXXXXXXXXX( Run->id, Run );
        XXXXXXXXXXXXXXX( Run->id, XXXXXXXXXXXXX );
        Run->initCB( Run->id, Run->ud );
        unsetenv( key->txt );
    }
    return NULL;
}


static pthread_t pawrun_pthread( XXXXXX run )
{
    XXXX txt = NULL;
    XXXXX key = XXXXXXXX, val = BAD_XXXXXXXX;
    XXXXX addr = 0;
    XXXXXX Run = NULL;
    XXXXXXXX( &key, run, XXXXXXXXXXX );
    XXXXXXX( key.txt, key.len, XXXXXXXXXX, sizeof(XXXXXXXXXX)-1 );
    txt = getenv( key.txt );
    XXXXXXX( val.txt, txt, XXXXXXXX(txt) );
    XXXXXXXXXXX( &addr, &val, XXXXXXXXXXXX );
    Run = (void*)addr;
    return Run->thread;
}

There really isn't much left that has any context for me, I'm sure others here feel the same way.

I'm not asking for an explanation of what "pawsu2pawju()" does, or even what a "pawsu" or "pawju" is, I just want to make you aware that what you ask relies heavily on stuff nobody here knows, so you won't get meaningful answers.

Originally Posted by hamster_nz

I just want to show you why people here aren't able to offer you much useful advice. It might just be my failings.

I've gone through the last code snipped, and replaced everything that has no meaning to me with XXXXs, even after a few attempts to Google things (e.g. pawsu2pawju - Google Search )

Code:

void* pawRUN_initCB( void *ud )
{
    XXXXXX Run = ud;
    XXXXXXX = Run;
    Run->tid = XXXXXXXXXXXX();
    if ( Run->initCB )
    {
        XXXXX *key = &(Run->env_key), *val = &(Run->env_val);
        XXXXXXXXXXX( key, Run->tid, XXXXXXXXXX );
        XXXXXXXXXXX( val, (XXXXX)Run, XXXXXXXXXXXX );
        XXXXXXX( key->txt, key->len, XXXXXXXXXX, sizeof(XXXXXXXXXX) - 1 );
        setenv( key->txt, val->txt, 1 );
        XXXXXXXXXXXXX( Run->id, Run );
        XXXXXXXXXXXXXXX( Run->id, XXXXXXXXXXXXX );
        Run->initCB( Run->id, Run->ud );
        unsetenv( key->txt );
    }
    return NULL;
}


static pthread_t pawrun_pthread( XXXXXX run )
{
    XXXX txt = NULL;
    XXXXX key = XXXXXXXX, val = BAD_XXXXXXXX;
    XXXXX addr = 0;
    XXXXXX Run = NULL;
    XXXXXXXX( &key, run, XXXXXXXXXXX );
    XXXXXXX( key.txt, key.len, XXXXXXXXXX, sizeof(XXXXXXXXXX)-1 );
    txt = getenv( key.txt );
    XXXXXXX( val.txt, txt, XXXXXXXX(txt) );
    XXXXXXXXXXX( &addr, &val, XXXXXXXXXXXX );
    Run = (void*)addr;
    return Run->thread;
}

There really isn't much left that has any context for me, I'm sure others here feel the same way.

I'm not asking for an explanation of what "pawsu2pawju()" does, or even what a "pawsu" or "pawju" is, I just want to make you aware that what you ask relies heavily on stuff nobody here knows, so you won't get meaningful answers.

well the paw* calls I'm not expecting anyone to have an exact understanding of, just a rough idea from the code, basically just turning the thread id & the pointer into text that can be added to the environment variables to then be read later when needed, the prefix inserted is just for distinguishing the number from other variables that happen to use the same number (assuming it is the case is better than assuming it is not the case)

Edit: Btw pawrun just maps to either HANDLE or thread id:

Code:

#ifdef PAW_ON_WINDOWS
typedef void* pawrun;
#define BAD_pawrun NULL
#else
typedef pawjd pawrun;
#define BAD_pawrun -1
#endif

Wanted a reasonably short name for it and even if the typedef is not enough the typedef following it gives enough meaning about it's rough purpose:

Code:

typedef void* (*pawrun_cb)( pawd id, void *ud );
typedef struct _PAW_THREAD PAW_THREAD, *pawRUN;
typedef const PAW_THREAD *PAWRUN;

I'll probably do a mass replace later to paw_thread but for now to help my fingers I'm using shorthands