int main()
{
printf("Should not print any errors.\n");
long i;
gtthread_t threads[NUM_THREADS];
gtthread_init(1000);
gtthread_mutex_init(&g_mutex);
for (i = 0; i < NUM_THREADS; ++i) {
gtthread_create(&threads[i], worker, (void*) i);
}
for (i = 0; i < NUM_THREADS; ++i) {
gtthread_join(threads[i], NULL);
}
if (g_num != NUM_THREADS) {
fprintf(stderr,
"!ERROR! Wrong result! %d != %d\n",
g_num, NUM_THREADS);
}
return 0;
}
int main() {
gtthread_t t1, t2, t3, t4, t5;
gtthread_init(1000);
gtthread_mutex_init(>tm);
gtthread_create(&t1, func1, (void*) 1);
gtthread_create(&t2, func1, (void*) 2);
gtthread_join(t1, NULL);
gtthread_join(t2, NULL);
gtthread_mutex_lock(>tm);
gtthread_create(&t3, func2, (void*) 3);
gtthread_create(&t4, func2, (void*) 4);
printf("This should print before threads 3 and 4 finish\n");
gtthread_mutex_unlock(>tm);
gtthread_join(t3, NULL);
gtthread_join(t4, NULL);
printf("Testing yield with one schedulable thread... ");
gtthread_yield();
gtthread_yield();
gtthread_yield();
printf("done!\n");
printf("Deadlocking with thread 5...\n");
gtthread_mutex_lock(>tm);
gtthread_create(&t5, func3, NULL);
gtthread_join(t5, NULL);
gtthread_mutex_unlock(>tm);
printf("!!! ERROR !!! Failed to deadlock with thread 5\n");
return 0;
}
void main () {
int i;
gtthread_init(100000);
for (i=0; i<5; i++) {
gtthread_mutex_init(&chopstick[i]);
gtthread_create(&philosopher[i], (void *)dining, (int *)(i+1));
}
gtthread_exit(NULL);
}
int main(){
gtthread_init(10000);
gtthread_mutex_init(&m1);
gtthread_mutex_init(&m2);
gtthread_mutex_init(&m3);
gtthread_mutex_init(&m4);
gtthread_mutex_init(&m5);
gtthread_create(&t1, philosopher, (void*)1);
gtthread_create(&t2, philosopher, (void*)2);
gtthread_create(&t3, philosopher, (void*)3);
gtthread_create(&t4, philosopher, (void*)4);
gtthread_create(&t5, philosopher, (void*)5);
while(1);
}
int
main (int argn,
char **argv)
{
int i;
gtthread_init( 10 );
if (argn == 2)
sleep_seconds = atoi (argv[1]);
gtthread_mutex_init (&food_lock);
for (i = 0; i < PHILOS; i++)
gtthread_mutex_init (&chopstick[i]);
for (i = 0; i < PHILOS; i++)
gtthread_create (&philo[i], philosopher, (void *)i);
for (i = 0; i < PHILOS; i++)
gtthread_join (philo[i], NULL);
return 0;
}
int main() {
int i;
gtthread_t t1, t2, t3, t6;
void *ret;
gtthread_mutex_init(&count_lock);
gtthread_init(5);
gtthread_create(&t1, thr1, (void *) 1);
gtthread_create(&t2, thr2, (void *) 2);
gtthread_create(&t3, thr3, (void *) 3);
gtthread_create(&t6, thr6, (void *) 6);
for (i = 0; i < LOOP_MAX; i++) {
printf("Main thread!\n");
fflush(stdout);
gtthread_mutex_lock(&count_lock);
count++;
gtthread_mutex_unlock(&count_lock);
if (i % YIELD_VAL == 0) {
gtthread_yield();
}
}
printf("main waiting for thr1...\n");
fflush(stdout);
gtthread_join(t1, &ret);
printf("thr1 joined main with value %d!\n", (int) ret);
fflush(stdout);
gtthread_cancel(t2);
printf("thr2 cancelled!\n");
fflush(stdout);
printf("main waiting for thr3...\n");
fflush(stdout);
gtthread_join(t3, &ret);
printf("thr3 joined main with value %d!\n", (int) ret);
fflush(stdout);
printf("main waiting for thr6...\n");
fflush(stdout);
gtthread_join(t6, &ret);
printf("thr6 joined main with value %d!\n", (int) ret);
fflush(stdout);
gtthread_mutex_lock(&count_lock);
printf("Final count value: %lu\n", count);
fflush(stdout);
gtthread_mutex_unlock(&count_lock);
gtthread_mutex_destroy(&count_lock);
return EXIT_SUCCESS;
}
int main() {
gtthread_init(3000);
gtthread_t philosopher[5];
int i;
for(i = 0; i < 5; i++) {
gtthread_create(&philosopher[i], (void *) whateverphilosophersaresupposedtodo, (void *) i);
chopstick[i] = malloc(sizeof(gtthread_mutex_t));
gtthread_mutex_init(chopstick[i]);
}
while(1);
return 0;
}
int main(void) {
gtthread_t ids[N];
gtthread_init(1000L);
gtthread_mutex_init(&g_mutex);
gtthread_t threads[N];
for(i = 0; i<N; i++) {
gtthread_create(&threads[i], main_loop, (void*)i);
}
while(1);
}
int main() {
printf("test6b. Should print 'main hello' then 'thr1 hello' and 'thr2 hello' for 5 times interleaving (but no mixed up prints e.g. 'th1 thr2 hello hello')\n");
gtthread_init(50000L);
gtthread_mutex_init(&g_mutex);
gtthread_mutex_lock(&g_mutex);
gtthread_create( &t1, thr1, NULL);
gtthread_create( &t2, thr2, NULL);
gtthread_yield();
printf("main hello\n");
gtthread_mutex_unlock(&g_mutex);
gtthread_join(t2, NULL);
gtthread_join(t1, NULL);
return EXIT_SUCCESS;
}
int main()
{
printf("Should print 'thread 1 (3x) then thread 0 (3x).\n");
gtthread_t th1, th2;
gtthread_init(1000);
gtthread_mutex_init(&g_mutex);
gtthread_create(&th1, worker, (void*)1);
gtthread_create(&th2, worker, (void*)2);
gtthread_join(th1, NULL);
gtthread_join(th2, NULL);
return 0;
}
void main(){
gtthread_init( 1000 );
int i;
gtthread_mutex_init(&test);
for (i = 0; i < 10; i++)
gtthread_create (&threads[i], thread_func, (void *)i);
for (i = 0; i < 10; i++)
{
//gtthread_join (threads[i], NULL);
//printf("Thread[%d] has exited\n", i);
}
usleep(10000000);
printf("Main exit\n");
}
int main() {
int i;
char *a;
void *b;
int c = 1000000;
gtthread_init(100000L);
gtthread_mutex_init(&g_mutex);
//gtthread_mutex_lock(&g_mutex);
gtthread_create( &t1, thr1, &c);
//printf("id:%d\n", t1);
//while(c--);
gtthread_create( &t2, thr1, &c);
// printf("id:%d\n", t2);
//printf("Exiting Main\n");
// while(1);
/*for (i = 0; i< 5; i++){
printf("Exiting Main\n");
while(c--);
c = 1000000;}*/
//gtthread_mutex_unlock(&g_mutex);
//gtthread_yield();
//gtthread_exit(NULL);
//gtthread_mutex_lock(&g_mutex);
//gtthread_create( &t1, thr1, &c);
//gtthread_mutex_unlock(&g_mutex);
// gtthread_join(t1, &b);
//printf("b:%s\n", (char*) b);
//gtthread_join(t2, &b);
//a = (int*) killed[0].ret;
//gtthread_yield();
while(1);
//gtthread_cancel(t1);
//gtthread_exit(NULL);
return EXIT_SUCCESS;
}
int main() {
gtthread_t t1;
gtthread_t t2;
gtthread_t t3;
double sum_thread1 = 0;
double *p1 = &sum_thread1;
double **p2 = &p1;
gtthread_mutex_init(&g_mutex);
gtthread_init(10000);
gtthread_create(&t1, thr1, NULL );
gtthread_create(&t2, thr2, NULL );
gtthread_create(&t3, thr3, NULL );
printf("id of thread1 is %d\n", t1.id);
printf("id of thread1 is %d\n", t2.id);
// get self id
gtthread_t t0;
t0 = gtthread_self();
printf("The main thread is %d \n", t0.id);
//gtthread_yield();
//gtthread_cancel(t2);
gtthread_join(t1, (void **) p2);
printf("Returned Value from thread 1 = %f\n", **p2);
gtthread_join(t2, NULL );
gtthread_join(t3, NULL );
printf("returning to main thread!\n");
// printf("returning to main thread again!\n");
gtthread_mutex_destroy(&g_mutex);
printf("\n....Exiting the Main!....\n");
return EXIT_SUCCESS;
}
int main()
{
void* status = (void*)100;
printf("test mutex lock, unlock\n");
printf("main: enter\n");
gtthread_init(period);
gtthread_mutex_init(period);
for( ndx=0; ndx<5; ++ndx ) {
gtthread_create( &t[ndx], thrX, status);
gtthread_create( &t[ndx+10], thrR, status);
}
for( ndx=0; ndx<5; ++ndx ) {
gtthread_join( t[1], &status);
}
printf("main: exit\n");
fflush(stdout);
return EXIT_SUCCESS;
}
main()
{
int i;
gtthread_init(100);
gtthread_t philosopher_thread[CHOPSTICKS];
int dn[CHOPSTICKS];
void *diner();
// intializing all the locks
for (i=0;i<CHOPSTICKS;i++){
gtthread_mutex_init(&chopstick_mutex[i]);
philosopher_status[i]=INITIAL;
}
// creating the philosphers
for (i=0;i<CHOPSTICKS;i++){
dn[i] = i;
gtthread_create(&philosopher_thread[i],diner,&dn[i]);
}
gtthread_exit(0);
// while(1)
}
void initialize()
{
void* a;
int i = 0;
gtthread_init(10000);
for(i = 0; i < NO_OF_PHILOSOPHERS; i++)
{
gtthread_mutex_init(&chopsticks[i]);
}
for(i = 0; i <NO_OF_PHILOSOPHERS; i++)
{
a = &i;
gtthread_create(&threads[i], tryToEat, a);
}
}
int main()
{
gtthread_t t1;
gtthread_t t2;
gtthread_t t3;
double sum_thread1 = 0;
double *p1 = &sum_thread1;
double **p2 = &p1;
gtthread_mutex_init(&g_mutex);
gtthread_init(1000);
gtthread_create(&t1, thr1, NULL );
printf("thread1 id %ld\n", t1); //t1.id);
gtthread_create(&t2, thr2, NULL );
printf("thread2 id %ld\n", t2); //t2.id);
gtthread_create(&t3, thr3, NULL );
printf("thread3 id %ld\n", t3); //t2.id);
// get self id
gtthread_t t0;
t0 = gtthread_self();
printf("main thread id %ld \n", t0); //t0.id);
//gtthread_yield();
gtthread_cancel(t2);
//gtthread_join(t1, NULL);
gtthread_join(t1, p2);
printf("thread1 return = %f\n", **p2);
gtthread_join(t2, NULL );
gtthread_join(t3, NULL );
printf("returning to main thread!\n");
// printf("returning to main thread again!\n");
gtthread_mutex_destroy(&g_mutex);
printf("\n....Exiting the Main!....\n");
return EXIT_SUCCESS;
}
int main()
{
gtthread_t threads[NO_OF_PHILOSOPHERS];
int i = 0;
gtthread_init(50);
for(i = 0; i < NO_OF_PHILOSOPHERS; i++)
{
gtthread_mutex_init(&chopstickLock[i]);
number_of_tries[i] = 0;
}
for(i = 0; i < NO_OF_PHILOSOPHERS; i++)
{
//threads[i] = (gtthread_t*)malloc(sizeof(gtthread_t));
gtthread_create(&threads[i], &perform, i);
}
while(1)
{;}
return 0;
}
int main()
{
int rc;
int rep;
int ndx;
printf("test mutex init, lock, unlock, destroy\n");
for( ndx=0; ndx<100; ++ndx ) {
hold[ndx] = 100+(ndx%10)*10;
}
printf("main: enter\n");
gtthread_init(period);
for( ndx=0; ndx<10; ++ndx ) {
rc = gtthread_mutex_init(&m[ndx]);
printf("init %d\n",ndx); fflush(stdout);
if(rc)printf("rc = %d\n",rc); fflush(stdout);
}
for( rep=0; rep<10; ++rep ) {
for( ndx=0; ndx<10; ++ndx ) {
rc = gtthread_mutex_lock(&m[ndx]);
printf("lock(%d)\n",ndx); fflush(stdout);
if(rc)printf("rc = %d\n",rc); fflush(stdout);
usleep(10*1000);
rc = gtthread_mutex_unlock(&m[ndx]);
printf("unlock(%d)\n",ndx); fflush(stdout);
if(rc)printf("rc = %d\n",rc); fflush(stdout);
}
}
for( ndx=0; ndx<10; ++ndx ) {
rc = gtthread_mutex_destroy(&m[ndx]);
printf("destroy(%d)\n",ndx,rc); fflush(stdout);
if(rc)printf("rc = %d\n",rc); fflush(stdout);
}
printf("main: exit\n");
fflush(stdout);
return EXIT_SUCCESS;
}
