Define (and declare and use) global variables from function through macros - c++

Question

I’m trying to reimplement in a backward-compatible way the RobotC API from C (although some details such as automatical inclusion of stdbool, optional parameters, references, I/O through “array”/subscript notation value/assignment, etc. would better fit C++ and some issues may be easier to solve in C++…). This one includes void startTask(void TaskID, short nTaskPriority) and void stopTask(void TaskID) to enable multithreading.
TaskID is meant to directly be the name of the function to run in a new thread. So no thread number variable there, only the global-scope function name. I first tried to implement something near this using macro identifier concatenation and external variables, but I can’t define a global variable from inside a function (using extern would result in a declaration rather than a definition, and a definition in a function is by default in local scope), so I end up with something that works only in the same scope (or stopping from an inner scope would work, but not the other way).
How could I do something alike? for example how to define (for example using some complex macro trick, a gcc extension (though I’d prefer to stay standard if possible, but wouldn’t bother too much if a such feature required gcc), or whatever?) a global, preferably multi-file, namespace-unique, made-up variable, for storing the pthread id?
#include <stdlib.h>
#include <pthread.h>
#include <stdarg.h>
#include <sched.h>
#include "misc.c"
const short kHighPriority = 255;
const short kLowPriority = 0;
const short kDefaultTaskPriority = 7;
/* void startTask(void TaskID,
short nTaskPriority = kDefaultTaskPriority) */
pthread_t
startTask (task (*TaskID)(void*), short nTaskPriority)
{
pthread_attr_t attr;
pthread_t thread;
struct sched_param param;
const int policy = sched_getscheduler(0),
sched_high_prio = sched_get_priority_max(policy), // 19,
sched_low_prio = sched_get_priority_min(policy), // -20,
sched_range_prio = sched_high_prio - sched_low_prio;
pthread_attr_init (&attr);
pthread_attr_getinheritsched(&attr, PTHREAD_INHERIT_SCHED);
pthread_attr_getschedparam (&attr, &param);
param.sched_priority = -(((nTaskPriority
- kLowPriority) * sched_range_prio
/ kHighPriority) + sched_low_prio);
pthread_attr_setschedparam (&attr, &param);
pthread_create (&thread, &attr, (void*) TaskID, NULL);
return thread;
}
void
stopTask (pthread_t thread)
{
pthread_cancel(thread);
}
void
stopAllTasks ()
{
exit(0);
}
#define startTask(task, priority) \
static pthread_t task##_thread = startTask(task, priority)
#define stopTask(task) \
stopTask(task##_thread)
I’d prefer, ideally, to solve this problem without external (that is, non-standard) libraries, at compile time, with C instead of C++, standard (C11 doesn’t disturb me) if possible, in this order (!gcc-specific || ! cxx || compile-time || stdc).
That is, except if something else is found, I’m okay with C++, even more with GNU extensions and totally okay with C/C++11 to solve this problem at compile-time instead of runtime, for instance (though my reimplementation seems mostly standard to me, global-scope multithreading requiring GNU doesn’t seems too much).

Answer 1

I would use a dictionary. A dictionary associates keys with values. The key is this case would by the task name, converted to a string. And the value would be the thread ID from pthread_create.
The dictionary itself could be implemented any way you like: hash table, binary tree, linked list, or even an array. The dictionary interface consists of three functions: Add(), Find(), and Remove().
To use the dictionary, the startTask and stopTask macros convert the function name to a string using the # operator. The string is then passed to the StartTask and StopTask functions and used as the key in the dictionary.
Here's some sample code that demonstrates the concepts:
#include <stdio.h>
#include <stdbool.h>
#include <pthread.h>
#define startTask(task, priority) startTask(#task, task, priority)
#define stopTask(task) stopTask(#task)
void dictionaryAdd(char *key, pthread_t threadID)
{
printf("Adding key: %s\n", key);
// add the key with its associated threadID to the dictionary
}
bool dictionaryFind(char *key, pthread_t *threadID)
{
printf("Finding key: %s\n", key);
// find the key in the dictionary and get the associated threadID
*threadID = 0;
return true;
}
void dictionaryRemove(char *key)
{
// remove the key and associated value from the dictionary
printf("Removing key: %s\n", key);
}
void startTask(char *name, ...)
{
pthread_t threadID = 0;
pthread_create(&threadID, ...);
dictionaryAdd(name, threadID);
}
void stopTask(char *name)
{
pthread_t threadID;
if (dictionaryFind(name, &threadID))
{
pthread_cancel(threadID);
dictionaryRemove(name);
}
}
void *foo(void *arg)
{
return NULL;
}
int main(void)
{
startTask(foo, 10);
stopTask(foo);
}
The output from the code:
Adding key: foo
Finding key: foo
Removing key: foo