lthread_cond_t *makemore

lthread_cond_create(&makemore);

lthread_cond_wait(makemore,0);

lthread_cond_broadcast(makemore);

gcc  --std=gnu11 -D_REENTRANT -pthread  -Wall threadxample.c -o thxc  -llthread `PKG_CONFIG_PATH=/usr/x86_64-linux-gnu;`

#include <lthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

/*each lthread which will wait for that signal, and report **
** its serial number is represented in, and passed a copy ***
** of this struct. I hope it's self explanatory enough***/

typedef struct whatiam{
		int 			serialnumber;
		lthread_cond_t		*mysignal;
		char			**myinstructions;
		lthread_t		*my_lightweight_thread_variable;
} me_t;

lthread_t	*an_lthread_signals;
pthread_t	a_pthread_signals;

/*these globals are set through environment variables***
** with the exact same spelling.*/

int pthreadsig,  //1=broadcast cond variable from in a pthread
	randquit,  //1=lthreads will quit eventually at random
	usecondsig;  //0=don't broadcast condition variable

lthread_cond_t	*serialnumber_lthread_wakeup_signal;

char *set_to_quit_or_not = "don't quit";

const int yes = 1,
	no = 0;

//returns from 0 to maximum
// generate random numbers for sleep and wait functions
int
intrand( int maximum ){
  if (!maximum)return 0;
  unsigned long intermediate = rand();
  intermediate *= (abs(maximum)+1);
  intermediate /= INT_MAX;
  return (int)intermediate;
}

void lthread_thread(void *who_I_am){
	me_t *myself = who_I_am;
	for(;;){
		int report = lthread_cond_wait(myself->mysignal, intrand(20)+1);
                //nonblocking sleep from 1 to 21 millisecond for signal then resumes
		if (!report){//return of zero means woke from the signal
			if(!strcmp("quit", *myself->myinstructions)){
				printf("serial number:\t %i\tSIGNALLED TO QUIT!\n\n", myself->serialnumber);
				break;
			}else{
				printf("serial number:\t %i\treporting!\t", myself->serialnumber);
			}
		}else if (report==-2){  // if the lthread_cond_wait times out it reports -2
				printf("timed out!!!:\t %i\ttimed out!!!\t", myself->serialnumber);
			}else{ // other return values not defined in the API
				printf("\n\nabnormal return from lthread_cond_wait\n\n");
				break;
			}
			if((randquit)&&(intrand(50)>49)){ //random quitting helpful if no cond. signal is broadcast
				printf("\nserial number:\t %i\tQUITTING AT RANDOM!!!\n", myself->serialnumber);
				break;
			}
		}
		return;
}

void *pthread_signals_controls_lthreads(void *unused){
// the loop below should make the threads report their numbers
	for(int i = 0; i < 10; i++){
		usleep(50000);// nonblocking sleep for 20ms (20000us)
		printf("\n\npthread is now calling lthread_cond_broadcast() to signal lthreads to report\n\n");
		lthread_cond_broadcast(serialnumber_lthread_wakeup_signal);
	}
	// now they should all report quitting and serial numbers
	set_to_quit_or_not = "quit";
	printf("\n\npthread is now calling lthread_cond_broadcast() to signal lthreads to quit\n\n");
	lthread_cond_broadcast(serialnumber_lthread_wakeup_signal);
	printf("\n\nlthread_cond_broadcast() has returned now the lthreads should be quitting\n\n");
	return NULL;
}

void lthread_signals_controls_lthreads(void *unused){
	for(int i = 0; i < 10; i++){
		printf("\n\nlthread is now calling lthread_cond_broadcast() to signal lthreads to report\n\n");
		lthread_cond_broadcast(serialnumber_lthread_wakeup_signal);
		lthread_sleep(50);// nonblocking sleep for 20 ms
	}
	// now they should all report quitting and serial numbers
	set_to_quit_or_not = "quit";
	printf("\n\nlthread is now calling lthread_cond_broadcast() to signal lthreads to quit\n\n");
	lthread_cond_broadcast(serialnumber_lthread_wakeup_signal);
	printf("\n\nlthread_cond_broadcast() has returned now the lthreads should be quitting\n\n");

	return NULL;
}


void *pthread_launches_lthreads(void *unused){
	lthread_cond_create(&serialnumber_lthread_wakeup_signal);
	const int number_of_lthreads = 20;
	set_to_quit_or_not = "don't quit";
	me_t	*array_of_lthreads = malloc(number_of_lthreads*sizeof(me_t));
	for (int i = 0; i < number_of_lthreads; i++){
		array_of_lthreads[i].serialnumber = i;
		array_of_lthreads[i].mysignal = serialnumber_lthread_wakeup_signal;
		array_of_lthreads[i].myinstructions = &set_to_quit_or_not;
/* The thread is represented by this:
array_of_lthreads[i].my_lightweight_thread_variable
the function serving as the start of the thread is
lthread_thread the data passed to the thread is a
structure: &array_of_lthreads[i]
alternately array_of_lthreads+i could have been used*/
		lthread_create(&array_of_lthreads[i].my_lightweight_thread_variable, lthread_thread, &array_of_lthreads[i]);
	}
	if((usecondsig)&&(pthreadsig)){
		pthread_create(&a_pthread_signals, NULL, pthread_signals_controls_lthreads, NULL);
	}else if(usecondsig){
		lthread_create(&an_lthread_signals, lthread_signals_controls_lthreads, NULL);
	}
/*the next function starts the lthread scheduler which will
schedule all the lthreads created using lthread_create within
this pthread. You can also create lthreads and run them from
main();
once the lthread scheduler is running the pthread is effectively paused until all the lthreads exit*/
	lthread_run();
	printf("\n\nthe lthread scheduler has run out of lthreads to schedule\n\n");
	return NULL;
}


int main(int argc, char **argv){


	char *envvar = getenv("pthreadsig");
	pthreadsig = envvar ? atoi(envvar): yes;

 	envvar = getenv("randquit");
	randquit = envvar ? atoi(envvar): no;

	envvar = getenv("usecondsig");
	usecondsig = envvar ? atoi(envvar): no;

	pthread_t	create_launch_lthreads;

	pthread_create(&create_launch_lthreads, NULL, pthread_launches_lthreads, NULL);

	pthread_join(create_launch_lthreads, NULL);
	return 0;
}

gcc  --std=gnu11  -g -pg -fms-extensions -D_REENTRANT -pthread  -Wall multischedthreadx.c -o thxxc  -llthread `PKG_CONFIG_PATH=/usr/x86_64-linux-gnu;`

gcc   -D_REENTRANT -pthread  -Wall multischedthreadx.c -o thxxc  -llthread `PKG_CONFIG_PATH=/usr/x86_64-linux-gnu;`

#include <lthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

typedef struct whatiam{
		int 						serialnumber;
		lthread_cond_t	**mysignal;
		int							*myinstructions;
		lthread_t				*my_lightweight_thread_variable;
} me_t;

typedef struct _signaller_info {
		int 						bottom;
		int							range;
		int							howmanyloops;
		lthread_cond_t  **mylthread_cond_variable;
		pthread_cond_t	*my_sync_signal;
} signaller_info;

int randquit;  //if nonzero lthreads will quit eventually at random with a 1/randquit chance

uint64_t syncfreq;

const int yes = 1,
	no = 0,
	quit = 1,
	cont = 0;
int set_to_quit_or_not = 0;

lthread_cond_t	*serialnumber_lthread_wakeup_signal,
									*thing_one, *thing_two;

pthread_cond_t 	dual_wakeup = PTHREAD_COND_INITIALIZER,
								thing1_wakeup = PTHREAD_COND_INITIALIZER,
								thing2_wakeup = PTHREAD_COND_INITIALIZER;
pthread_mutex_t likely_unused_mutex = PTHREAD_MUTEX_INITIALIZER;



int
intrand( int maximum ){
  if (!maximum)return 0;
  unsigned long intermediate = rand();
  intermediate *= (abs(maximum)+1);
  intermediate /= INT_MAX;
  return (int)intermediate;
}


void lthread_thread(void *who_I_am){
	me_t *myself = who_I_am;
	printf("\nnow in  lthread_thread  function...sn: %i\n", myself->serialnumber);
	for(;;){
		int report = lthread_cond_wait(*(myself->mysignal), intrand(33));
		if (!report){//return of zero means woke from the signal
			printf("sn:\t %i\treporting!\n", myself->serialnumber);
		}else if(report==-2){  //if timed out it reports -2
			if(set_to_quit_or_not == quit){
				printf("\nsn:\t %i\ttimed out and\tSIGNALLED TO QUIT!\n", myself->serialnumber);
				break;
			}else
				printf("sn:\t %i\t\ttimed out!!!\n", myself->serialnumber);
		}else{ // other return values not defined in the API
			printf("\n~~~~~~~~~~~~~~~~~~~~~~~~~\nabnormal return from lthread_cond_wait\n~~~~~~~~~~~~~~~~~\n");
			break;
		}
		if((randquit)&&(intrand(randquit)>randquit-1)){ //random quitting helpful if no cond. signal is broadcast
			printf("\nserial number:\t %i\t\t\tQUITTING AT RANDOM!!!\n", 	myself->serialnumber);
			break;
		}
	}
	lthread_exit(NULL);
	return;
}

void lthread_signals_controls_lthreads(void *data){
	signaller_info *myinfo = data;
	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nnow in lthread signaller thread, serving sn.s %i to %i\n", myinfo->bottom, myinfo->bottom+19);
	for(int i = 0; i < myinfo->howmanyloops; i++){
		/*between lthread_compute_begin() lthread_compute_end() we aren't blocking other lthreads*/
		lthread_compute_begin();
			usleep(syncfreq*100);
			printf("\nlthread signaller %i waiting on pthread_cond_wait\n", myinfo->bottom);
			pthread_cond_wait(myinfo->my_sync_signal, &likely_unused_mutex);
			printf("lthread signaller  %i waited on pthread_cond_wait\n", myinfo->bottom);
			if(set_to_quit_or_not == quit){
				printf("\n\nsignaller %i broadcasting for lthreads to quit\n\n", myinfo->bottom);
				/*we can compute_end because then we beak out of the loop with the other compute_end() */
				lthread_compute_end();
				break;
			}
		lthread_compute_end();
		printf("\n\nsignaller %i is now broadcasting for lthreads to report\n\n", myinfo->bottom);
		lthread_cond_broadcast(*myinfo->mylthread_cond_variable);
	}
	printf("\n\nsignaller %i broadcasting for lthreads to quit\n\n", myinfo->bottom);
	lthread_cond_broadcast(*myinfo->mylthread_cond_variable);
	printf("\n\nsignaller %i has finished broadcasting lthreads to quit\n\n", myinfo->bottom);
	usleep(80000);
	printf("\n\nsignaller %i now exiting\n\n", myinfo->bottom);
	lthread_exit((void*)myinfo->mylthread_cond_variable);
}

void *pthread_launches_lthreads(void *data){
	signaller_info *myinfo = data;
	lthread_cond_t *cond_variable;
	lthread_cond_create(&cond_variable);
	printf("\nnow in  pthread_launches_lthreads %i bottom\n", myinfo->bottom);

	for (int i = myinfo->bottom; i < myinfo->range+myinfo->bottom; i++){
		me_t *an_lthread_object = malloc(sizeof(me_t));
		an_lthread_object->serialnumber = i;
		an_lthread_object->myinstructions = &set_to_quit_or_not;
		an_lthread_object->mysignal = &cond_variable;
		lthread_create(&an_lthread_object->my_lightweight_thread_variable, lthread_thread, an_lthread_object);
		printf("\nnow in  pthread_launches %i bottom launching lthread\n", myinfo->bottom);
	}
	myinfo->mylthread_cond_variable = &cond_variable;
	lthread_t *an_lthread_signals;
	lthread_create(&an_lthread_signals, lthread_signals_controls_lthreads, (void*)myinfo);
	lthread_run();
	return NULL;
}

void*
two_lthread_scheduler_coordinator(void *data){
	pthread_t launchthread1,
						launchthread2;
	signaller_info *siginfdata = malloc(sizeof(signaller_info));
	set_to_quit_or_not = cont;

	printf("\nnow in two_lthread_scheduler_coordinator function\n");
	siginfdata->bottom = 0;
	siginfdata->range = 20;
	siginfdata->howmanyloops = 3000;
	siginfdata->my_sync_signal = &dual_wakeup;
	pthread_create(&launchthread1, NULL, pthread_launches_lthreads, (void*)siginfdata);
	siginfdata = malloc(sizeof(signaller_info));
	siginfdata->bottom = 21;
	siginfdata->range = 20;
	siginfdata->howmanyloops = 1000;
	siginfdata->my_sync_signal = &dual_wakeup;
	pthread_create(&launchthread2, NULL, pthread_launches_lthreads, (void*)siginfdata);
	int *cond_sig_frequency = data;
	for(;;){
		usleep(*cond_sig_frequency);
		pthread_cond_signal(&dual_wakeup);////pthread_cond_signal(&thing2_wakeup);
		if(intrand(10000) > 9999){
			set_to_quit_or_not = quit;
			printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~\n~~~~~~~~~~~~~~~~~~~~~\n~~~~~~~~~~~~~~~~~~~~~~~set quit signal-everyone should quit real real soon now\n");
			usleep(100000);
			break;
		}
	}
	return NULL;
}

int main(int argc, char **argv){


 	char *envvar = getenv("randquit");
	randquit = envvar ? atoi(envvar): no;

	envvar = getenv("syncfreq");
	syncfreq = envvar ? atoi(envvar): 200;

	two_lthread_scheduler_coordinator( (void*)&syncfreq);

	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
	printf("\n please excuse sloppiness.\n setting syncfreq to something under 200 works well\non the computer this was written on\n\nset randquit and each thread has a 1/randquit chance of\nquiting each time it loops\n\n");
	printf("\n\nrandquit and synfreq are environmental variables\nenter randquit=[your number here] and hit return then enter export randquit\nsame for syncfreq\n");


	printf("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

	return 0;
}