balanced_bug.csv

text,label
"#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <signal.h>
#include <unistd.h>

//A structure that contains the data
// to be passed to a new thread
struct DataForThread {
	char name[36];
	int limit;
	int grouping;
};

//This is the function we want to run
// in new threads using the pthreads library
void*  workerThreadFunc(void* data);

//Pointer to the mutex used to
// synchronize threads
pthread_mutex_t * mutex;

int main() {
	//the number of threads to start
	int numThreads = 5;

	//the id's of the threads we will start
	pthread_t threadIds[numThreads];

	//initialize the mutex
	mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
	pthread_mutex_init(mutex,NULL);

	//create all the threads
	for(int i=1;i<=numThreads;i++) {
		//create a data structure containing
		// the data the new thread will need
		struct DataForThread * dft = (struct DataForThread *) malloc(sizeof(struct DataForThread));
		sprintf(dft->name,""Thread%d"",i);
		dft->limit = i * 10;
		dft->grouping = i;

		//launch the thread with 'workerThreadFunc' as its main
		pthread_create(&threadIds[i - 1],NULL,workerThreadFunc,dft);
	}

	//wait for the threads to complete
	for(int i=1;i<=numThreads;i++) {
		printf(""Waiting for thread %d\\n"",i);
		pthread_join(threadIds[i - 1],0);
		printf(""Thread %d exited\\n"",i);
	}
	free(mutex);
	printf(""Program complete...\\n"");
}

//many copies of this method will be run, each in a different thread
void* workerThreadFunc(void* data) {
	struct DataForThread* info = (struct DataForThread*)data;

	int count = 1;
	while(count <= info->limit) {
		//acquire the lock
		pthread_mutex_lock(mutex);
		//print the correct number of messages
		for(int i=0;i<info->grouping;i++) {
			printf(""%s message %d of %d\\n"",info->name,count++,info->limit);
			sleep(1);
		}
		//release the lock
		pthread_mutex_unlock(mutex);
	}

	free(info);
	return 0;
}",1
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS  4
#define TOTAL_COUNT 10
#define COUNT_LIMIT 12

int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

void *inc_count(void *t)
{
    int i;
    long my_id = (long)t;

    for (i = 0; i < TOTAL_COUNT; i++) {
        pthread_mutex_lock(&count_mutex);
        count++;

        /*
         * Check the value of count and signal waiting thread when
         * condition is reached. Note that this occurs while mutex
         * is locked.
         */
        if (count == COUNT_LIMIT) {
            printf(""inc_count(): thread %ld, count = %d  Threshold reached. "",
                my_id, count);
            pthread_cond_signal(&count_threshold_cv);
            printf(""Just sent signal.\\n"");
        }
        printf(""inc_count(): thread %ld, count = %d, unlocking mutex\\n"",
            my_id, count);
        pthread_mutex_unlock(&count_mutex);

        /* Do some work so threads can alternate on mutex lock */
        sleep(1);
    }
    pthread_exit(NULL);
}

void *watch_count(void *t)
{
    long my_id = (long)t;

    printf(""watch_count(): thread %ld\\n"", my_id);

    /*
     * Lock mutex and wait for signal.  Note that the pthread_cond_wait
     * routine will automatically and atomically unlock mutex while it
     * waits. Also, note that if COUNT_LIMIT is reached before this routine
     * is run by the waiting thread, the loop will be skipped to prevent
     * pthread_cond_wait from never returning.
     */
    pthread_mutex_lock(&count_mutex);
    while (count < COUNT_LIMIT) {
        printf(""watch_count(): thread %ld Count= %d. Going into wait...\\n"", my_id, count);
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf(""watch_count(): thread %ld Condition signal received. Count= %d\\n"", my_id, count);
    }
    printf(""watch_count(): thread %ld Updating the value of count...\\n"", my_id);
    count += 125;
    printf(""watch_count(): thread %ld count now = %d.\\n"", my_id, count);
    printf(""watch_count(): thread %ld Unlocking mutex.\\n"", my_id);
    pthread_mutex_unlock(&count_mutex);
    pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
    int i;
    long t1=1, t2=2, t3=3, t4=4;
    pthread_t threads[NUM_THREADS];
    pthread_attr_t attr;

    /* Initialize mutex and condition variable objects */
    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init(&count_threshold_cv, NULL);

    /* For portability, explicitly create threads in a joinable state */
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
    pthread_create(&threads[2], &attr, inc_count, (void *)t3);
    pthread_create(&threads[3], &attr, inc_count, (void *)t4);

    /* Wait for all threads to complete */
    for (i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    printf (""main(): waited and joined with %d threads. Final value of count = %d. Done.\\n"",
        NUM_THREADS, count);

    /* Clean up and exit */
    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    pthread_exit(NULL);
}

",0
"/* filename: timedwait.c
   purpose: CMPS 360 week 05  - example code


   Demonstrate the two POSIX thread synchronization primitives - mutex and 
   the condition variable. Demonstrate the condition using the 
   cond_timedwait() function, which you should use instead of sleep since 
   sleep applies to the entire process not just a single thread.

   Primitives used:

   int pthread_mutex_init (pthread_mutex_t *__mutex,
             __const pthread_mutexattr_t *__mutexattr)


   int pthread_cond_timedwait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex,
              const struct timespec *restrict abstime);

   Read relevant manpages for more detailed information. To compile and link
   you must link in the pthread and librt libraries:

           $ gcc timedwait.c -lpthread -lrt     */

#include <stdio.h>
#include <time.h>
#include <unistd.h>

#include <stdlib.h>
#include <pthread.h>

void * p1_func( void *ptr );
void * p2_func( void *ptr );

pthread_t t1, t2;
pthread_mutex_t mutex;
pthread_cond_t cond;
struct timespec ts;

main()
{
     char *msg1 = ""Hello     "";
     char *msg2 = ""World    \\n"";

     /* initialize a mutex */
     pthread_mutex_init(&mutex, NULL);

     /* create t1, use default attributes, pass print_msg function */
     if ( (pthread_create( &t1, NULL, p1_func, (void *) msg1)) < 0) {
         perror(""pthread_create"");
         exit(EXIT_FAILURE);
     }

     if ( (pthread_create( &t2, NULL, p2_func, (void *) msg2) ) < 0) {
         perror(""pthread_create"");
         exit(EXIT_FAILURE);
     }

      /* rejoin from threads */
    if (  (pthread_join(t1, NULL)) < 0 ) {
         perror(""pthread_join"");
         exit(EXIT_FAILURE);
     }
     if (  (pthread_join(t2, NULL)) < 0 ) {
         perror(""pthread_join"");
         exit(EXIT_FAILURE);
     }


     exit(0);
}


void * p1_func( void *ptr )
{
    char *message;
    message = (char *) ptr;
    int rc; /* return code */
     

    clock_gettime(CLOCK_REALTIME, &ts);  /* must link in librt library */
    ts.tv_sec += 3;
    rc = 0; /* return code is ETIMEDOUT when 3 seconds have passed */ 

    /* this will force a timeout */
    while ( rc == 0)
       rc = pthread_cond_timedwait(&cond, &mutex, &ts); 


    
    write(1,message,10);
}

void * p2_func( void *ptr )
{
     char *message;
     message = (char *) ptr;
     fprintf(stderr,""%s "", message);
}
",1
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

#define THREADS_NUM 3

// Node structure for the list
typedef struct List {
    int value;
    struct List *next;
} List;

struct List *lista = NULL; // Initialize list as NULL

pthread_mutex_t mutex;
sem_t sem;

// Function to display the list
void display(struct List *element) {
    printf(""["");
    while (element) {
        printf(""%d"", element->value);
        if (element->next) {
            printf("", "");
        }
        element = element->next;
    }
    printf(""]\\n"");
}

// Function to insert an element at the end of the list
void push_f(int value) {
    struct List *newElement;
    struct List *cursor = lista;
    newElement = (struct List *)malloc(sizeof(struct List));
    newElement->value = value;
    newElement->next = NULL;

    if (lista == NULL) {
        lista = newElement;  // If list is empty, new element becomes the head
    } else {
        // Traverse to the end of the list
        while (cursor->next) {
            cursor = cursor->next;
        }
        cursor->next = newElement; // Insert at the end
    }
}

// Function to remove the last element from the list
int pop_f() {
    if (lista == NULL) {
        return -1; // List is empty
    }

    struct List *cursor = lista;
    struct List *prev = NULL;

    // Traverse to the last element
    while (cursor->next) {
        prev = cursor;
        cursor = cursor->next;
    }

    int return_value = cursor->value;

    // Remove the last element
    if (prev == NULL) { // List had only one element
        free(cursor);
        lista = NULL;
    } else {
        free(cursor);
        prev->next = NULL;
    }

    return return_value;
}

// Wrapper function to remove elements from the list for a thread
void *popThread(void *arg) {
    while (1) {
        sem_wait(&sem);
        pthread_mutex_lock(&mutex);

        int val = pop_f();
        if (val != -1) {
            printf(""Thread removed: %d\\n"", val);
        } else {
            printf(""Thread tried to remove from an empty list.\\n"");
        }
        display(lista);

        pthread_mutex_unlock(&mutex);
        sleep(3); // Simulate some work
    }
    return NULL;
}

// Wrapper function to add elements to the list for a thread
void *pushThread(void *arg) {
    while (1) {
        int val = rand() % 100;

        pthread_mutex_lock(&mutex);

        push_f(val);
        printf(""Thread inserted: %d\\n"", val);
        display(lista);

        pthread_mutex_unlock(&mutex);

        sem_post(&sem); // Signal that an element was added

        sleep(1); // Simulate some work
    }
    return NULL;
}

int main() {
    pthread_t tid[THREADS_NUM];
    pthread_mutex_init(&mutex, NULL);
    sem_init(&sem, 0, 0); // Initialize semaphore with 0

    srand(time(NULL));

    // Create threads: 1 push thread and 2 pop threads
    pthread_create(&tid[0], NULL, pushThread, NULL);
    pthread_create(&tid[1], NULL, popThread, NULL);
    pthread_create(&tid[2], NULL, popThread, NULL);

    // Wait for threads to finish (they run indefinitely in this case)
    for (int i = 0; i < THREADS_NUM; i++) {
        pthread_join(tid[i], NULL);
    }

    // Clean up
    sem_destroy(&sem);
    pthread_mutex_destroy(&mutex);

    // Free the list
    while (lista) {
        pop_f();
    }

    return 0;
}

",0
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/resource.h>

double get_time(){
        struct timeval t;
        struct timezone tzp;
        gettimeofday(&t, &tzp);
        return t.tv_sec + t.tv_usec*1e-6;
}


void *increment_counter(void *ptr);

int counter = 0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

int main(){
	int x;
	double startTime = get_time();
	for(x = 0; x < 1000; x++){
		counter = 0;
		pthread_t thread1, thread2, thread3, thread4;
		int amount1 = 100;
		int amount2 = 100;
		int amount3 = 100;
		int amount4 = 100;
		int iret1, iret2, iret3, iret4;
		iret1 = pthread_create( &thread1, NULL, increment_counter,(void *) &amount1);
		iret2 = pthread_create( &thread2, NULL, increment_counter,(void *) &amount2);
		iret3 = pthread_create( &thread3, NULL, increment_counter,(void *) &amount3);
		iret4 = pthread_create( &thread4, NULL, increment_counter,(void *) &amount4);
		
		pthread_join(thread1, NULL);
		pthread_join(thread2, NULL);
		pthread_join(thread3, NULL);
		pthread_join(thread4, NULL);
		
		if(counter != 400){	
			//printf(""%d\\n"", counter);
		}
		
	}
	double endTime = get_time();
	double total_time = endTime - startTime;
	printf(""%f\\n"", total_time);
}

void *increment_counter(void *ptr){
	int *amount;
	amount= (int *) ptr;
	int i;
	for(i = 0; i < *amount; i++){
		
		pthread_mutex_lock( &mutex1);
		counter++;
		pthread_mutex_unlock( &mutex1);
	}
}
",1
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define BSIZE 4
#define NUMITEMS 30

typedef struct {
  char buf[BSIZE];
  int occupied;
  int nextin, nextout;
  pthread_mutex_t mutex;
  pthread_cond_t more;
  pthread_cond_t less;
} buffer_t;

buffer_t buffer;

void *producer(void *);
void *consumer(void *);

#define NUM_THREADS 2
pthread_t tid[NUM_THREADS]; /* array of thread IDs */

int main(int argc, char *argv[])
{
  int i;

  // Initialize buffer and its associated synchronization primitives
  buffer.occupied = 0;
  buffer.nextin = 0;
  buffer.nextout = 0;

  pthread_mutex_init(&(buffer.mutex), NULL);
  pthread_cond_init(&(buffer.more), NULL);
  pthread_cond_init(&(buffer.less), NULL);

  // Create threads: producer first, consumer second
  pthread_create(&tid[0], NULL, producer, NULL);
  pthread_create(&tid[1], NULL, consumer, NULL);

  // Wait for both threads to finish
  for (i = 0; i < NUM_THREADS; i++) {
    pthread_join(tid[i], NULL);
  }

  printf(""\\nmain() reporting that all %d threads have terminated\\n"", NUM_THREADS);

  // Cleanup resources
  pthread_mutex_destroy(&(buffer.mutex));
  pthread_cond_destroy(&(buffer.more));
  pthread_cond_destroy(&(buffer.less));

  return 0;
} /* main */

void *producer(void *parm)
{
  char item[NUMITEMS] = ""IT'S A SMALL WORLD, AFTER ALL."";
  int i;

  printf(""producer started.\\n"");
  fflush(stdout);

  for(i = 0; i < NUMITEMS; i++) {
    if (item[i] == '\\0') break;  /* Quit if at end of string. */

    pthread_mutex_lock(&(buffer.mutex));

    // Wait if buffer is full
    while (buffer.occupied >= BSIZE) {
      printf(""producer waiting.\\n"");
      fflush(stdout);
      pthread_cond_wait(&(buffer.less), &(buffer.mutex));
    }

    // Insert item into buffer
    buffer.buf[buffer.nextin++] = item[i];
    buffer.nextin %= BSIZE;
    buffer.occupied++;

    printf(""producer produced: %c\\n"", item[i]);
    fflush(stdout);

    // Signal consumer that more items are available
    pthread_cond_signal(&(buffer.more));
    pthread_mutex_unlock(&(buffer.mutex));

    // Simulate work
    usleep(100000);  // Slow down the producer for demonstration
  }

  printf(""producer exiting.\\n"");
  fflush(stdout);
  pthread_exit(0);
}

void *consumer(void *parm)
{
  char item;
  int i;

  printf(""consumer started.\\n"");
  fflush(stdout);

  for(i = 0; i < NUMITEMS; i++) {
    pthread_mutex_lock(&(buffer.mutex));

    // Wait if buffer is empty
    while(buffer.occupied <= 0) {
      printf(""consumer waiting.\\n"");
      fflush(stdout);
      pthread_cond_wait(&(buffer.more), &(buffer.mutex));
    }

    // Consume item from buffer
    item = buffer.buf[buffer.nextout++];
    buffer.nextout %= BSIZE;
    buffer.occupied--;

    printf(""consumer consumed: %c\\n"", item);
    fflush(stdout);

    // Signal producer that there is space available
    pthread_cond_signal(&(buffer.less));
    pthread_mutex_unlock(&(buffer.mutex));

    // Simulate work
    usleep(150000);  // Slow down the consumer for demonstration
  }

  printf(""consumer exiting.\\n"");
  fflush(stdout);
  pthread_exit(0);
}

",0
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

int arr[100];
int target;
pthread_mutex_t mutex;
int found = 0; // Shared variable to indicate if target is found

void* binary_search(void* arg) {
    int* range = (int*) arg;
    int low = range[0], high = range[1];

    if (low > high || found) return NULL;

    int mid = (low + high) / 2;

    
    if (arr[mid] == target) {
        found = 1;
        printf(""Element found at index %d\\n"", mid);
    }
    

    if (!found) {
        pthread_t left_thread, right_thread;
        int left_range[] = {low, mid - 1};
        int right_range[] = {mid + 1, high};

        pthread_create(&left_thread, NULL, binary_search, left_range);
        pthread_create(&right_thread, NULL, binary_search, right_range);

        pthread_join(left_thread, NULL);
        pthread_join(right_thread, NULL);
    }
    return NULL;
}

int main() {
    int n = 100; // Size of array
    target = 50; // Example target to search for
    for (int i = 0; i < n; i++) arr[i] = i; // Fill array with sorted values

    pthread_mutex_init(&mutex, NULL);

    pthread_t thread;
    int range[] = {0, n - 1};
    pthread_create(&thread, NULL, binary_search, range);
    pthread_join(thread, NULL);

    pthread_mutex_destroy(&mutex);

    if (!found) printf(""Element not found\\n"");
    return 0;
}
",1
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS  3
#define TCOUNT 10
#define COUNT_LIMIT 12

int     count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

void *inc_count(void *t){
      
    int i;
    long my_id = (long)t;

    for(i=0; i < TCOUNT; i++){
        pthread_mutex_lock(&count_mutex);
        count++;

        /* 
        *checa o valor de count
        *quando a condicao e alcancada o mutex e liberado
        */
        if(count == COUNT_LIMIT){
            
            printf(""inc_count(): thread %ld, count = %d  Threshold reached. "",my_id, count);
            pthread_cond_signal(&count_threshold_cv);
            printf(""Just sent signal.\\n"");
        }
        
        printf(""inc_count(): thread %ld, count = %d, unlocking mutex\\n"",my_id, count);
        pthread_mutex_unlock(&count_mutex);
                  
        sleep(1);
    }
    
    pthread_exit(NULL);
}

void *watch_count(void *t){

    long my_id = (long)t;

    printf(""Starting watch_count(): thread %ld\\n"", my_id);

    /*
    *fecha mutex e espera trigger da condicao
    */
      
    pthread_mutex_lock(&count_mutex);
        
    while(count < COUNT_LIMIT){
        printf(""watch_count(): thread %ld Count= %d. Going into wait...\\n"", my_id,count);
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf(""watch_count(): thread %ld Condition signal received. Count= %d\\n"", my_id,count);
        printf(""watch_count(): thread %ld Updating the value of count...\\n"", my_id,count);
        count += 125;
        printf(""watch_count(): thread %ld count now = %d.\\n"", my_id, count);
    }
          
    printf(""watch_count(): thread %ld Unlocking mutex.\\n"", my_id);
    pthread_mutex_unlock(&count_mutex);
    pthread_exit(NULL);
}

void main(){

    int i, rc; 
    long t1=1, t2=2, t3=3;
    pthread_t threads[3];
    pthread_attr_t attr;

    /* inicializa mutex e variaveis de condicao */
    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init (&count_threshold_cv, NULL);

    /* para propositos de portabilidade, cria threads em um estado na qual podem
     * ser juntadas (join)*/
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
    pthread_create(&threads[2], &attr, inc_count, (void *)t3);

    /* espera todas as threads terminarem */
    for (i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf (""Main(): Waited and joined with %d threads. Final value of count = %d. Done.\\n"", NUM_THREADS, count);

    /* limpa e sai */
    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    
    pthread_exit (NULL);
}

",0
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

int arr[100];
int target;
pthread_mutex_t mutex;
int found = 0; // Shared variable to indicate if target is found

void* binary_search(void* arg) {
    int* range = (int*) arg;
    int low = range[0], high = range[1];

    if (low > high || found) return NULL;

    int mid = (low + high) / 2;

    
    if (arr[mid] == target) {
        found = 1;
        printf(""Element found at index %d\\n"", mid);
    }
    

    if (!found) {
        pthread_t left_thread, right_thread;
        int left_range[] = {low, mid - 1};
        int right_range[] = {mid + 1, high};

        pthread_create(&left_thread, NULL, binary_search, left_range);
        pthread_create(&right_thread, NULL, binary_search, right_range);

        pthread_join(left_thread, NULL);
        pthread_join(right_thread, NULL);
    }
    return NULL;
}

int main() {
    int n = 100; // Size of array
    target = 50; // Example target to search for
    for (int i = 0; i < n; i++) arr[i] = i; // Fill array with sorted values

    pthread_mutex_init(&mutex, NULL);

    pthread_t thread;
    int range[] = {0, n - 1};
    pthread_create(&thread, NULL, binary_search, range);
    pthread_join(thread, NULL);

    pthread_mutex_destroy(&mutex);

    if (!found) printf(""Element not found\\n"");
    return 0;
}
",1
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define FILE_SIZE 671088640  // 800 MB
#define BUFFER_SIZE 8

int thread_count = 0;
int server_file_des, bytes_read;
unsigned long long int block_size = 0, file_pos = 0, total_bytes = 0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

void *receive_data(void *thread_id) {
    unsigned long long int start_pos, end_pos;
    unsigned long long int local_bytes = 0;
    char buffer[BUFFER_SIZE];

    pthread_mutex_lock(&mutex1);
    start_pos = file_pos;
    file_pos += block_size;
    pthread_mutex_unlock(&mutex1);

    end_pos = start_pos + block_size;

    struct sockaddr_in client_addr;
    socklen_t addr_len = sizeof(client_addr);

    while (start_pos < end_pos) {
        bytes_read = recvfrom(server_file_des, buffer, BUFFER_SIZE, 0, (struct sockaddr*)&client_addr, &addr_len);
        
        if (bytes_read > 0) {
            local_bytes += bytes_read;
            start_pos += bytes_read;
            printf(""Thread %ld transferred %llu bytes (total transferred: %llu bytes)\\n"", (long)thread_id, local_bytes, start_pos);
        } else {
            perror(""recvfrom"");
            break;
        }
    }

    pthread_mutex_lock(&mutex1);
    total_bytes += local_bytes;
    pthread_mutex_unlock(&mutex1);

    pthread_exit(NULL);
}

int main() {
    int ch;
    printf(""Perform Network Benchmarking on\\n1. 1 Thread\\n2. 2 Threads\\n3. 4 Threads\\n4. 8 Threads\\n"");
    scanf(""%d"", &ch);

    if (ch == 1 || ch == 2 || ch == 3 || ch == 4) {
        thread_count = (ch == 4) ? 8 : ch == 3 ? 4 : ch;
        printf(""Number of Threads: %d\\n"", thread_count);
    } else {
        printf(""Invalid Choice\\nProgram terminated\\n"");
        return 0;
    }

    struct sockaddr_in address;
    int addrlen = sizeof(address);

    // Create UDP socket
    if ((server_file_des = socket(AF_INET, SOCK_DGRAM, 0)) == 0) {
        perror(""Socket failed"");
        exit(EXIT_FAILURE);
    }

    // Setup server address
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(5000);

    // Bind the socket
    if (bind(server_file_des, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror(""Bind failed"");
        exit(EXIT_FAILURE);
    }

    // Divide the workload among threads
    block_size = FILE_SIZE / thread_count;

    pthread_t threads[thread_count];
    for (long j = 0; j < thread_count; j++) {
        pthread_create(&threads[j], NULL, receive_data, (void*)j);  // Thread Creation
    }

    for (int k = 0; k < thread_count; k++) {
        pthread_join(threads[k], NULL);  // Wait for all threads to complete
    }

    printf(""Total bytes transferred: %llu bytes\\n"", total_bytes);

    close(server_file_des);
    return 0;
}

",0
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

pthread_mutex_t mutex;
int fib_cache[1000]; // Shared cache for memoization

void* fibonacci(void* arg) {
    int n = *(int*) arg;
    if (n <= 1) return (void*) (size_t) n;

    pthread_t thread1, thread2;
    int n1 = n - 1, n2 = n - 2;
    void* res1;
    void* res2;

    pthread_create(&thread1, NULL, fibonacci, &n1);
    pthread_create(&thread2, NULL, fibonacci, &n2);

    pthread_join(thread1, &res1);
    pthread_join(thread2, &res2);

    int result = (size_t) res1 + (size_t) res2;

    
    fib_cache[n] = result;
    

    return (void*) (size_t) result;
}

int main() {
    int n = 10; // Example Fibonacci number
    pthread_mutex_init(&mutex, NULL);

    pthread_t thread;
    pthread_create(&thread, NULL, fibonacci, &n);

    void* result;
    pthread_join(thread, &result);

    printf(""Fibonacci of %d is %zu\\n"", n, (size_t) result);
    pthread_mutex_destroy(&mutex);

    return 0;
}
",1
"#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>

#define BUF_SIZE 16

pthread_mutex_t my_mutex;

typedef struct Student {
    char name[BUF_SIZE];
    char surname[BUF_SIZE];
    int grade;
} Student;

Student temp;

void* fun_write(void *arg) {
    while (1) {
        for (int i = 0; i < 2; i++) {
            pthread_mutex_lock(&my_mutex);
            if (i % 2) {
                strcpy(temp.name, ""Przemyslaw"");
                strcpy(temp.surname, ""Nowak"");
                temp.grade = 5;
            } else {
                strcpy(temp.name, ""Adam"");
                strcpy(temp.surname, ""Kazimierczak"");
                temp.grade = 2;
            }
            pthread_mutex_unlock(&my_mutex);
            sleep(1);  // Add a small delay
        }
    }
    return NULL;
}

void* fun_read(void* arg) {
    Student local;
    while (1) {
        pthread_mutex_lock(&my_mutex);
        memcpy(&local, &temp, sizeof(Student));
        pthread_mutex_unlock(&my_mutex);
        
        printf(""====================================\\n"");
        printf(""%s\\n"", local.name);
        printf(""%s\\n"", local.surname);
        printf(""%d\\n"", local.grade);
        sleep(1);  // Add a small delay to prevent busy waiting
    }
    return NULL;
}

int main() {
    pthread_t thread_write, thread_read;
    
    pthread_mutex_init(&my_mutex, NULL);

    pthread_create(&thread_write, NULL, fun_write, NULL);
    pthread_create(&thread_read, NULL, fun_read, NULL);
    
    pthread_join(thread_write, NULL);  // Blocks indefinitely since threads run in infinite loop
    pthread_join(thread_read, NULL);

    pthread_mutex_destroy(&my_mutex);
    return 0;
}

",0
"#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

int matrice[10][4] = { {8, 25, 3, 41},
                       {11, 18, 3, 4},
                       {4, 15, 78, 12},
                       {1, 12, 0, 12},
                       {7, 9, 13, 15},
                       {4, 21, 37, 89},
                       {1, 54, 7, 3},
                       {15, 78, 7, 1},
                       {12, 15, 13, 47},
                       {91, 13, 72, 90} };

int vecteur[4] = {1, 2, 3, 4};

int resultat[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // col resultat
pthread_mutex_t mutex;

void* computeVector(void* arg) {
    int column = *((int*)arg);  // Correctly pass the argument by dereferencing it
    free(arg);  // Free dynamically allocated memory for the thread argument
    
    for (int i = 0; i < 10; i++) {
        
        resultat[i] = resultat[i] + matrice[i][column] * vecteur[column];
        
    }
    
    return NULL;
}

int main() {
    if (pthread_mutex_init(&mutex, NULL) != 0) {
        perror(""ERROR INITIALIZING MUTEX"");
        return 1;
    }

    pthread_t thread_ids[4];
    
    for (int i = 0; i < 4; i++) {
        int* arg = malloc(sizeof(*arg));  // Allocate memory for each thread argument
        if (arg == NULL) {
            perror(""ERROR ALLOCATING MEMORY"");
            return 1;
        }
        *arg = i;
        
        if (pthread_create(&thread_ids[i], NULL, computeVector, arg) != 0) {
            perror(""ERROR CREATING THREAD"");
            return 1;
        }
    }

    for (int i = 0; i < 4; i++) {
        if (pthread_join(thread_ids[i], NULL) != 0) {
            perror(""ERROR JOINING THREAD"");
            return 1;
        }
    }

    // Print the result
    for (int i = 0; i < 10; i++) {
        printf(""\\n%d"", resultat[i]);
    }

    pthread_mutex_destroy(&mutex);
    return 0;
}

",1
"#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#define errExit(str) \\
    do { perror(str); exit(-1); } while(0)

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

static size_t i_gloabl_n = 0;

void *thr_demo(void *args)
{
    printf(""this is thr_demo thread, pid: %d, tid: %lu\\n"", getpid(), pthread_self());
    pthread_mutex_lock(&mutex);
    
    int i;
    int max = *(int *)args;
    size_t tid = pthread_self();
    setbuf(stdout, NULL);
    for (i = 0; i < max; ++i) {
        printf(""(tid: %lu):%lu\\n"", tid, ++i_gloabl_n);
    }

    pthread_mutex_unlock(&mutex);  // Unlock the mutex after critical section
    return (void *)10;
}

void *thr_demo2(void *args)
{
    printf(""this is thr_demo2 thread, pid: %d, tid: %lu\\n"", getpid(), pthread_self());
    pthread_mutex_lock(&mutex);

    int i;
    int max = *(int *)args;
    size_t tid = pthread_self();
    setbuf(stdout, NULL);
    for (i = 0; i < max; ++i) {
        printf(""(tid: %lu):%lu\\n"", tid, ++i_gloabl_n);
    }

    pthread_mutex_unlock(&mutex);  // Unlock the mutex after critical section
    return (void *)10;
}

int main()
{
    pthread_t pt1, pt2;

    int arg = 20;
    int ret;

    ret = pthread_create(&pt1, NULL, thr_demo, &arg);
    if (ret != 0) {
        errExit(""pthread_create"");
    }

    ret = pthread_create(&pt2, NULL, thr_demo2, &arg);
    if (ret != 0) {
        errExit(""pthread_create"");
    }

    printf(""this is main thread, pid = %d, tid = %lu\\n"", getpid(), pthread_self());

    // Join the first thread and capture return value
    void *ret_val;
    ret = pthread_join(pt1, &ret_val);
    if (ret != 0) {
        errExit(""pthread_join"");
    }
    printf(""Thread 1 returned: %ld\\n"", (long)ret_val);

    // Join the second thread and capture return value
    ret = pthread_join(pt2, &ret_val);
    if (ret != 0) {
        errExit(""pthread_join"");
    }
    printf(""Thread 2 returned: %ld\\n"", (long)ret_val);

    // Clean up the mutex
    pthread_mutex_destroy(&mutex);

    return 0;
}

",0
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// http://www.cs.cmu.edu/afs/cs/academic/class/15492-f07/www/pthreads.html


void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

int main()
{
    int rc1, rc2;
    pthread_t thread1, thread2;

    /* Create independent threads each of which will execute functionC */

    if ((rc1 = pthread_create(&thread1, NULL, &functionC, NULL))) {
        printf(""Thread creation failed: %d\\n"", rc1);
        return -1;
    }

    if ((rc2 = pthread_create(&thread2, NULL, &functionC, NULL))) {
        printf(""Thread creation failed: %d\\n"", rc2);
        return -1;
    }

    /* Wait till threads are complete before main continues */
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;  // Exit with 0 indicating success
}

void *functionC()
{
    
    counter++;
    printf(""Counter value: %d\\n"", counter);
    
    return NULL;
}

",1
"#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>

#define CONSUMER_COUNT 2
#define PRODUCER_COUNT 2

typedef struct node_ {
    struct node_ *next;
    int num;
} node_t;

node_t *head = NULL;
pthread_t thread[CONSUMER_COUNT + PRODUCER_COUNT];
pthread_cond_t cond;
pthread_mutex_t mutex;

void* consume(void* arg) {
    int id = *(int*)arg;
    free(arg);  // Free the dynamically allocated id after use
    while (1) {
        pthread_mutex_lock(&mutex);

        while (head == NULL) {
            printf(""%d consume wait\\n"", id);
            pthread_cond_wait(&cond, &mutex);
        }

        // Consume the node
        node_t *p = head;
        head = head->next;
        printf(""Consumer %d consumed %d\\n"", id, p->num);

        pthread_mutex_unlock(&mutex);

        // Free the consumed node
        free(p);
    }
    return NULL;
}

void* produce(void* arg) {
    int id = *(int*)arg;
    free(arg);  // Free the dynamically allocated id after use
    int i = 0;

    while (1) {
        pthread_mutex_lock(&mutex);

        node_t *p = (node_t*)malloc(sizeof(node_t));
        memset(p, 0x00, sizeof(node_t));
        p->num = i++;
        p->next = head;
        head = p;

        printf(""Producer %d produced %d\\n"", id, p->num);

        // Signal one waiting consumer
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);

        sleep(1);  // Simulate work
    }
    return NULL;
}

int main() {
    int i = 0;
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);

    // Create consumer threads
    for (; i < CONSUMER_COUNT; i++) {
        int *p = (int*)malloc(sizeof(int));  // Dynamically allocate id
        *p = i;
        pthread_create(&thread[i], NULL, consume, (void*)p);
    }

    // Create producer threads
    for (i = 0; i < PRODUCER_COUNT; i++) {
        int *p = (int*)malloc(sizeof(int));  // Dynamically allocate id
        *p = i;
        pthread_create(&thread[i + CONSUMER_COUNT], NULL, produce, (void*)p);
    }

    // Wait for all threads to complete (which never happens in this case)
    for (i = 0; i < CONSUMER_COUNT + PRODUCER_COUNT; i++) {
        pthread_join(thread[i], NULL);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

",0
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <stdbool.h>

static pthread_once_t g_init = PTHREAD_ONCE_INIT;
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t g_lcd_lock = PTHREAD_MUTEX_INITIALIZER;
static struct light_state_t g_notification;
static struct light_state_t g_battery;

struct led_data {
    const char *max_brightness;
    const char *brightness;
    const char *delay_on;
    const char *delay_off;
    int blink;
};

struct led_data redled = {
    .max_brightness = ""/sys/class/leds/red/max_brightness"",
    .brightness = ""/sys/class/leds/red/brightness"",
    .delay_on = ""/sys/class/leds/red/delay_on"",
    .delay_off = ""/sys/class/leds/red/delay_off"",
    .blink = 0
};

struct led_data greenled = {
    .max_brightness = ""/sys/class/leds/green/max_brightness"",
    .brightness = ""/sys/class/leds/green/brightness"",
    .delay_on = ""/sys/class/leds/green/delay_on"",
    .delay_off = ""/sys/class/leds/green/delay_off"",
    .blink = 0
};

struct led_data blueled = {
    .max_brightness = ""/sys/class/leds/blue/max_brightness"",
    .brightness = ""/sys/class/leds/blue/brightness"",
    .delay_on = ""/sys/class/leds/blue/delay_on"",
    .delay_off = ""/sys/class/leds/blue/delay_off"",
    .blink = 0
};

struct led_data lcd = {
    .max_brightness = ""/sys/class/leds/lcd_backlight0/max_brightness"",
    .brightness = ""/sys/class/leds/lcd_backlight0/brightness"",
    .delay_on = ""/sys/class/leds/lcd_backlight0/delay_on"",
    .delay_off = ""/sys/class/leds/lcd_backlight0/delay_off"",
    .blink = 0
};

void init_globals(void) {
    pthread_mutex_init(&g_lock, NULL);
    pthread_mutex_init(&g_lcd_lock, NULL);
}

static int write_int(const char *path, int val) {
    int fd = open(path, O_WRONLY);
    if (fd < 0) {
        fprintf(stderr, ""Failed to open %s\\n"", path);
        return -1;
    }

    char buffer[20];
    int bytes = snprintf(buffer, sizeof(buffer), ""%d\\n"", val);
    ssize_t amt = write(fd, buffer, (size_t)bytes);
    close(fd);
    return amt == -1 ? -1 : 0;
}

static int read_int(const char *path) {
    char buffer[12];
    int fd = open(path, O_RDONLY);
    if (fd < 0) {
        fprintf(stderr, ""Failed to open %s\\n"", path);
        return -1;
    }

    int rc = read(fd, buffer, sizeof(buffer) - 1);
    close(fd);
    if (rc <= 0)
        return -1;

    buffer[rc] = 0;
    return strtol(buffer, NULL, 0);
}

static int is_lit(struct light_state_t const *state) {
    return state->color & 0x00ffffff;
}

static int rgb_to_brightness(struct light_state_t const *state) {
    int color = state->color & 0x00ffffff;
    return ((77 * ((color >> 16) & 0x00ff)) +
            (150 * ((color >> 8) & 0x00ff)) +
            (29 * (color & 0x00ff))) >> 8;
}

static int set_light_backlight(struct light_device_t *dev,
                               struct light_state_t const *state) {
    if (!dev)
        return -1;

    int brightness = rgb_to_brightness(state) * 39;
    
    int err = write_int(lcd.brightness, brightness);
    
    return err;
}

static int set_speaker_light_locked(struct light_device_t *dev,
                                    struct light_state_t const *state) {
    if (!dev)
        return -1;

    int red = (state->color >> 16) & 0xFF;
    int green = (state->color >> 8) & 0xFF;
    int blue = state->color & 0xFF;
    int delay_on = state->flashOnMS;
    int delay_off = state->flashOffMS;

    if (delay_on > 0 && delay_off > 0) {
        // Blinking logic
        if (red) {
            write_int(redled.delay_on, delay_on);
            write_int(redled.delay_off, delay_off);
        }
        if (green) {
            write_int(greenled.delay_on, delay_on);
            write_int(greenled.delay_off, delay_off);
        }
        if (blue) {
            write_int(blueled.delay_on, delay_on);
            write_int(blueled.delay_off, delay_off);
        }
    } else {
        // Static color
        write_int(redled.brightness, red);
        write_int(greenled.brightness, green);
        write_int(blueled.brightness, blue);
    }

    return 0;
}

static int close_lights(struct light_device_t *dev) {
    if (dev)
        free(dev);

    return 0;
}

static int open_lights(const struct hw_module_t *module, char const *name,
                       struct hw_device_t **device) {
    int (*set_light)(struct light_device_t *dev,
                     struct light_state_t const *state);

    if (0 == strcmp(LIGHT_ID_BACKLIGHT, name))
        set_light = set_light_backlight;
    else
        return -EINVAL;

    pthread_once(&g_init, init_globals);

    struct light_device_t *dev = malloc(sizeof(struct light_device_t));
    if (!dev)
        return -ENOMEM;

    memset(dev, 0, sizeof(*dev));
    dev->common.tag = HARDWARE_DEVICE_TAG;
    dev->common.version = 0;
    dev->common.module = (struct hw_module_t *)module;
    dev->common.close = (int (*)(struct hw_device_t *))close_lights;
    dev->set_light = set_light;

    *device = (struct hw_device_t *)dev;
    return 0;
}

static struct hw_module_methods_t lights_module_methods = {
    .open = open_lights,
};

struct hw_module_t HAL_MODULE_INFO_SYM = {
    .tag = HARDWARE_MODULE_TAG,
    .version_major = 1,
    .version_minor = 0,
    .id = LIGHTS_HARDWARE_MODULE_ID,
    .name = ""Honor 8 LED driver"",
    .author = ""Honor 8 Dev Team."",
    .methods = &lights_module_methods,
};

",1
"#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>

#define DATA_MAX 5
#define PRO_INIT_VAL (DATA_MAX / 2)
#define CON_INIT_VAL (DATA_MAX - PRO_INIT_VAL)
static int data;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mutex;
static sem_t sem_pro;
static sem_t sem_con;

static void *pro_handler(void *arg)
{
	ssize_t i = 100;

	for (; i > 0; --i) {
		//sem_wait(&sem_pro);
		pthread_mutex_lock(&mutex);

		++data;
		printf(""producter: data = %d\\n"", data);

		pthread_mutex_unlock(&mutex);
		//sem_post(&sem_con);
		pthread_cond_signal(&cond);
		usleep(100000);
	}

}

static void *con_handler(void *arg)
{
	ssize_t i = 100;

//	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

	for (; i > 0; --i) {
		//sem_wait(&sem_con);
		pthread_mutex_lock(&mutex);
		while (data == 0) {
			pthread_cond_wait(&cond, &mutex);
		}
		while (data > 0) {
			--data;
			printf(""consumer: data = %d\\n"", data);
		}
		pthread_mutex_unlock(&mutex);
		//sem_post(&sem_pro);
		sleep(1);
	}
}

int main()
{
	pthread_mutex_init(&mutex, NULL);

	sem_init(&sem_pro, 0, PRO_INIT_VAL);
	sem_init(&sem_con, 0, CON_INIT_VAL);

	data = CON_INIT_VAL;

	pthread_t pro_id, con_id;
	
	int pro_ret = 0;
	if (pro_ret = pthread_create(&pro_id, NULL, pro_handler, NULL)) {
		fprintf(stderr, ""pthread_create producter: %s"", strerror(pro_ret));
		goto err_create_producter;
	}

	int con_ret = 0;
	if (con_ret = pthread_create(&con_id, NULL, con_handler, NULL)) {
		fprintf(stderr, ""pthread_create consumer: %s"", strerror(con_ret));
		goto err_create_consumer;
	}
#if 0
	sleep(3);
	if (pthread_cancel(con_id)) {
		fprintf(stderr, ""error cancel\\n"");
	}
#endif
	pthread_join(pro_id, NULL);
	pthread_join(con_id, NULL);

	sem_destroy(&sem_con);
	sem_destroy(&sem_pro);
	pthread_mutex_destroy(&mutex);
	return 0;

	//pthread_join(con_id, NULL);
err_create_consumer:
	pthread_join(pro_id, NULL);
err_create_producter:
	sem_destroy(&sem_con);
	sem_destroy(&sem_pro);
	pthread_mutex_destroy(&mutex);
	return -1;
}
",0
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <errno.h>

struct udp_splice_handle {
    pthread_mutex_t lock;
    int sock;
    uint16_t id;
};

static int udp_splice_get_family_id(int sock) {
    struct {
        struct nlmsghdr nl;
        char buf[4096];
    } buf;
    struct genlmsghdr *genl;
    struct rtattr *rta;
    struct sockaddr_nl addr = {
        .nl_family = AF_NETLINK,
    };
    int len;

    memset(&buf.nl, 0, sizeof(buf.nl));
    buf.nl.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
    buf.nl.nlmsg_flags = NLM_F_REQUEST;
    buf.nl.nlmsg_type = GENL_ID_CTRL;

    genl = (struct genlmsghdr *)buf.buf;
    memset(genl, 0, sizeof(*genl));
    genl->cmd = CTRL_CMD_GETFAMILY;

    rta = (struct rtattr *)(genl + 1);
    rta->rta_type = CTRL_ATTR_FAMILY_NAME;
    rta->rta_len = RTA_LENGTH(sizeof(UDP_SPLICE_GENL_NAME));
    memcpy(RTA_DATA(rta), UDP_SPLICE_GENL_NAME, sizeof(UDP_SPLICE_GENL_NAME));
    buf.nl.nlmsg_len += rta->rta_len;

    if (sendto(sock, &buf, buf.nl.nlmsg_len, 0, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror(""sendto failed"");
        return -1;
    }

    len = recv(sock, &buf, sizeof(buf), 0);
    if (len < 0) {
        perror(""recv failed"");
        return -1;
    }
    if (len < sizeof(buf.nl) || buf.nl.nlmsg_len != len) {
        errno = EBADMSG;
        return -1;
    }
    if (buf.nl.nlmsg_type == NLMSG_ERROR) {
        struct nlmsgerr *errmsg = (struct nlmsgerr *)buf.buf;
        errno = -errmsg->error;
        return -1;
    }

    len -= sizeof(buf.nl) + sizeof(*genl);
    while (RTA_OK(rta, len)) {
        if (rta->rta_type == CTRL_ATTR_FAMILY_ID) {
            return *(uint16_t *)RTA_DATA(rta);
        }
        rta = RTA_NEXT(rta, len);
    }

    errno = EBADMSG;
    return -1;
}

void *udp_splice_open(void) {
    struct udp_splice_handle *h;
    int retval;
    struct sockaddr_nl addr;

    h = malloc(sizeof(*h));
    if (!h) {
        perror(""malloc failed"");
        return NULL;
    }

    retval = pthread_mutex_init(&h->lock, NULL);
    if (retval) {
        errno = retval;
        free(h);
        return NULL;
    }

    h->sock = socket(PF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK | SOCK_CLOEXEC, NETLINK_GENERIC);
    if (h->sock < 0) {
        perror(""socket creation failed"");
        pthread_mutex_destroy(&h->lock);
        free(h);
        return NULL;
    }

    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    if (bind(h->sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror(""bind failed"");
        close(h->sock);
        pthread_mutex_destroy(&h->lock);
        free(h);
        return NULL;
    }

    retval = udp_splice_get_family_id(h->sock);
    if (retval < 0) {
        close(h->sock);
        pthread_mutex_destroy(&h->lock);
        free(h);
        return NULL;
    }

    h->id = retval;
    return h;
}

int udp_splice_add(void *handle, int sock, int sock2, uint32_t timeout) {
    struct {
        struct nlmsghdr nl;
        struct genlmsghdr genl;
        char attrs[RTA_LENGTH(4) * 3];
    } req;
    struct {
        struct nlmsghdr nl;
        struct nlmsgerr err;
    } res;
    struct rtattr *rta;
    struct sockaddr_nl addr = { .nl_family = AF_NETLINK };
    int len;
    struct udp_splice_handle *h = handle;

    memset(&req, 0, sizeof(req.nl) + sizeof(req.genl));
    req.nl.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
    req.nl.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
    req.nl.nlmsg_type = h->id;

    req.genl.cmd = UDP_SPLICE_CMD_ADD;

    rta = (struct rtattr *)req.attrs;
    rta->rta_type = UDP_SPLICE_ATTR_SOCK;
    rta->rta_len = RTA_LENGTH(4);
    *(uint32_t *)RTA_DATA(rta) = sock;
    req.nl.nlmsg_len += rta->rta_len;

    rta = (struct rtattr *)(((char *)rta) + rta->rta_len);
    rta->rta_type = UDP_SPLICE_ATTR_SOCK2;
    rta->rta_len = RTA_LENGTH(4);
    *(uint32_t *)RTA_DATA(rta) = sock2;
    req.nl.nlmsg_len += rta->rta_len;

    if (timeout) {
        rta = (struct rtattr *)(((char *)rta) + rta->rta_len);
        rta->rta_type = UDP_SPLICE_ATTR_TIMEOUT;
        rta->rta_len = RTA_LENGTH(4);
        *(uint32_t *)RTA_DATA(rta) = timeout;
        req.nl.nlmsg_len += rta->rta_len;
    }

    pthread_mutex_lock(&h->lock);
    if (sendto(h->sock, &req, req.nl.nlmsg_len, 0, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        pthread_mutex_unlock(&h->lock);
        perror(""sendto failed"");
        return -1;
    }

    len = recv(h->sock, &res, sizeof(res), 0);
    pthread_mutex_unlock(&h->lock);

    if (len < 0) {
        perror(""recv failed"");
        return -1;
    }
    if (len != sizeof(res) || res.nl.nlmsg_type != NLMSG_ERROR) {
        errno = EBADMSG;
        return -1;
    }
    if (res.err.error) {
        errno = -res.err.error;
        return -1;
    }

    return 0;
}

// Other functions remain the same, with appropriate error handling and locking where needed.


",1
"#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>




typedef struct node
{
    int data;
    struct node* next;
}Node;


Node *head = NULL;


pthread_mutex_t mutex;

pthread_cond_t cond;


int produced_num = 0;

void* th_producer(void *args)
{
    while(1)
    {
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = rand() % 100;
  
        pthread_mutex_lock(&mutex);
        node->next = head;
        head = node;
        printf(""%lu生产了一个烧饼:%d\\n"",pthread_self(),head->data);
        pthread_mutex_unlock(&mutex);


        if(++produced_num==3)
        {
            pthread_cond_signal(&cond);
        }
        sleep(rand() % 3);
    }
    return NULL;
}

void* th_consumer(void *args)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);

        if(head == NULL)
        {
       
            pthread_cond_wait(&cond,&mutex);
            //continue;
           
        }
        Node * node = head;
        head = head->next;
        printf(""%lu消费了一个烧饼:%d\\n"",pthread_self(),node->data);
        free(node);
        produced_num--;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
int main()
{

    pthread_t thid_producer,thid_consumer;

    //init
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);


    pthread_create(&thid_producer,NULL,th_producer,NULL);

    pthread_create(&thid_consumer,NULL,th_consumer,NULL);


    pthread_join(thid_producer,NULL);
    pthread_join(thid_consumer,NULL);

    //destory
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}
",0
"#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <pthread.h>
#include <linux/spi/spidev.h>
#include <string.h>
#include <errno.h>

// Define the necessary constants
#define SPI_MODE SPI_MODE_0
#define SPI_BITS_PER_WORD 8
#define SPI_SPEED_HZ 500000
#define SPI_DELAY 0
#define FPGA_SPI_DEV ""/dev/spidev0.0""

// Define command constants (replace with actual values)
#define CMD_SERVO 0x01
#define CMD_SPEED_ACC_SWITCH 0x02
#define CMD_AS 0x03
#define CMD_LED 0x04
#define CMD_SPEED 0x05
#define CMD_SPEEDPOLL 0x06
#define CMD_SPEEDRAW 0x07
#define SPI_PREAMBLE 0xAA

// Utility macros
#define HIGHBYTE(x) ((x) >> 8)
#define LOWBYTE(x) ((x) & 0xFF)

int fd;
FILE *logfd = NULL;

static uint8_t spi_mode = SPI_MODE;
static uint8_t spi_bits = SPI_BITS_PER_WORD;
static uint32_t spi_speed = SPI_SPEED_HZ;
static uint16_t spi_delay = SPI_DELAY;

pthread_mutex_t spi_mutex;

int fpga_open() {
    int ret;

    pthread_mutex_init(&spi_mutex, NULL);

    printf(""Will use SPI to send commands to FPGA\\n"");
    printf(""SPI configuration:\\n"");
    printf(""    + dev: %s\\n"", FPGA_SPI_DEV);
    printf(""    + mode: %d\\n"", spi_mode);
    printf(""    + bits per word: %d\\n"", spi_bits);
    printf(""    + speed: %d Hz (%d KHz)\\n\\n"", spi_speed, spi_speed / 1000);

    if ((fd = open(FPGA_SPI_DEV, O_RDWR)) < 0) {
        perror(""E: fpga: spi: Failed to open dev"");
        return -1;
    }

    if ((ret = ioctl(fd, SPI_IOC_WR_MODE, &spi_mode)) < 0) {
        perror(""E: fpga: spi: can't set spi mode wr"");
        return -1;
    }

    if ((ret = ioctl(fd, SPI_IOC_RD_MODE, &spi_mode)) < 0) {
        perror(""E: fpga: spi: can't set spi mode rd"");
        return -1;
    }

    if ((ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &spi_bits)) < 0) {
        perror(""E: fpga: spi: can't set bits per word wr"");
        return -1;
    }

    if ((ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &spi_bits)) < 0) {
        perror(""E: fpga: spi: can't set bits per word rd"");
        return -1;
    }

    if ((ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed)) < 0) {
        perror(""E: fpga: spi: can't set speed wr"");
        return -1;
    }

    if ((ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &spi_speed)) < 0) {
        perror(""E: fpga: spi: can't set speed rd"");
        return -1;
    }

    if (fpga_logopen() < 0) {
        fprintf(stderr, ""E: fpga: could not open log\\n"");
        return -1;
    }

    return 0;
}

void fpga_close() {
    if (fd >= 0) {
        close(fd);
    }
    if (logfd) {
        fclose(logfd);
    }
    pthread_mutex_destroy(&spi_mutex);
}

int fpga_logopen() {
    logfd = fopen(""/tmp/ourlog"", ""a"");
    if (!logfd) {
        perror(""E: fpga: could not open log file"");
        return -1;
    }
    fprintf(logfd, ""--------reopened--------\\n"");
    return 0;
}

int spisend(unsigned char *rbuf, unsigned char *wbuf, int len) {
    int ret;

    

    struct spi_ioc_transfer tr = {
        .tx_buf = (unsigned long)wbuf,
        .rx_buf = (unsigned long)rbuf,
        .len = len,
        .delay_usecs = spi_delay,
        .speed_hz = spi_speed,
        .bits_per_word = spi_bits,
    };

    ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
    if (ret < 1) {
        perror(""E: fpga: can't send SPI message"");
        
        return -1;
    }

    
    return ret;
}

// Other FPGA control functions such as fpga_setservo, fpga_setspeedacc, fpga_as, etc.
// Follow a similar pattern as above for SPI communication and error handling.

void fpga_testservos() {
    if (fpga_open() < 0) {
        fprintf(stderr, ""E: FPGA: Could not open SPI to FPGA\\n"");
        exit(EXIT_FAILURE);
    }

    printf(""Moving servo left\\n"");
    fpga_setservo(1, 0);
    sleep(2);

    printf(""Moving servo centre\\n"");
    fpga_setservo(1, 4000);
    sleep(2);

    printf(""Moving servo right\\n"");
    fpga_setservo(1, 8000);
    sleep(2);

    printf(""Moving servo centre\\n"");
    fpga_setservo(1, 4000);

    fpga_close();
}

",1
"#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

#define NUM_THREAD 3  
#define TCOUNT 5
#define COUNT_LIMIT 7
int count = 0;

pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

// Increment the count
void *inc_count(void *t)
{
    int i;
    long my_id = (long)t;

    for (i = 0; i < TCOUNT; ++i)
    {
        pthread_mutex_lock(&count_mutex);
        count++;
        // Check if the count reaches the threshold and signal
        if (count >= COUNT_LIMIT)
        {
            printf(""inc_count(): thread %ld, count = %d Threshold reached. "",
                   my_id, count);
            // Send the signal
            pthread_cond_signal(&count_threshold_cv);
            printf(""Just sent signal.\\n"");
        }

        printf(""inc_count(): thread %ld, count = %d, unlocking mutex.\\n"",
               my_id, count);
        pthread_mutex_unlock(&count_mutex);

        sleep(1); // Simulate some work
    }

    pthread_exit(NULL);
}

// Watcher thread waiting for the count to reach the threshold
void *watch_count(void *t)
{
    long my_id = (long)t;
    printf(""Starting watch_count(): thread %ld.\\n"", my_id);

    // Lock the mutex and wait for the signal
    pthread_mutex_lock(&count_mutex);
    while (count < COUNT_LIMIT)
    {
        printf(""watch_count(): thread %ld going into wait...\\n"", my_id);
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf(""watch_count(): thread %ld Condition signal received.\\n"", my_id);

        printf(""watch_count(): thread %ld count now = %d.\\n"", my_id, count);
    }
    pthread_mutex_unlock(&count_mutex);
    
    pthread_exit(NULL);
}

int main()
{
    long t1 = 1, t2 = 2, t3 = 3;
    pthread_t threads[NUM_THREAD];
    pthread_attr_t attr;

    // Initialize mutex and condition variable
    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init(&count_threshold_cv, NULL);

    // Initialize thread attributes
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    // Create the watcher thread
    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
    // Create two incrementer threads
    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
    pthread_create(&threads[2], &attr, inc_count, (void *)t3);

    // Join threads
    for (int i = 0; i < NUM_THREAD; ++i)
    {
        pthread_join(threads[i], NULL);
    }

    printf(""Main(): Waited on %d threads, final value of count = %d. Done\\n"",
           NUM_THREAD, count);

    // Clean up
    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    pthread_exit(NULL);
}

",0
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define MAX_NODES 10

pthread_mutex_t dist_mutex;
int dist[MAX_NODES];

void* dijkstra(void* arg) {
    int u = *(int*)arg;
    
    // Update distances and relax edges for node u
    printf(""Processing node %d\\n"", u); // Debug output for testing
    
    free(arg); // Free the allocated memory
    return NULL;
}

int main() {
    pthread_mutex_init(&dist_mutex, NULL);

    // Graph and initial distance setup here

    pthread_t threads[MAX_NODES];
    for (int i = 0; i < MAX_NODES; i++) {
        int* node = malloc(sizeof(int));
        if (node == NULL) {
            perror(""Failed to allocate memory"");
            exit(1);
        }
        *node = i; // Assign the value of i to the dynamically allocated memory
        if (pthread_create(&threads[i], NULL, dijkstra, node) != 0) {
            perror(""Failed to create thread"");
            exit(1);
        }
    }

    for (int i = 0; i < MAX_NODES; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&dist_mutex);
    return 0;
}

",1
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <time.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>

char sourceFilename[500], destinationFilename[500];
char nonFlatSourceFilename[500], nonFlatDestinationFilename[500];

off_t offset = 0;
pthread_mutex_t offsetMutex = PTHREAD_MUTEX_INITIALIZER;
int copyingDone = 0;

// Function prototypes
void *copyWorker(void *arg);
void copyNonFlatFile();
void runDestinationVM();
void *sendOffset(void *recvConnection);
void connectionHandler(int connection);
void *runServer(void *arg);
void getVMsInfo(int debugMode);
void sendMessage(int connection, const char *message);
void createServer(void (*handler)(int));

void *copyWorker(void *arg) {
    char buf[4096];
    time_t startedAt = time(NULL);

    int sourceFd = open(sourceFilename, O_RDONLY);
    if (sourceFd < 0) {
        perror(""Error opening source file"");
        pthread_exit(NULL);
    }

    int destinationFd = open(destinationFilename, O_WRONLY | O_CREAT, 0666);
    if (destinationFd < 0) {
        perror(""Error opening destination file"");
        close(sourceFd);
        pthread_exit(NULL);
    }

    int res;
    do {
        pthread_mutex_lock(&offsetMutex);

        res = pread(sourceFd, buf, sizeof(buf), offset);
        if (res <= 0) {
            pthread_mutex_unlock(&offsetMutex);
            break;
        }

        if (pwrite(destinationFd, buf, res, offset) < 0) {
            perror(""Error writing to destination file"");
            pthread_mutex_unlock(&offsetMutex);
            close(sourceFd);
            close(destinationFd);
            pthread_exit(NULL);
        }

        offset += res;

        pthread_mutex_unlock(&offsetMutex);
    } while (res == sizeof(buf));

    close(sourceFd);
    close(destinationFd);

    time_t endedAt = time(NULL);
    printf(""Copying Done! in %ld seconds\\n"", (endedAt - startedAt));

    copyingDone = 1;
    pthread_exit(NULL);
}

void copyNonFlatFile() {
    char buf[4096];
    off_t nonFlatOffset = 0;

    time_t startedAt = time(NULL);

    int nonFlatSourceFd = open(nonFlatSourceFilename, O_RDONLY);
    if (nonFlatSourceFd < 0) {
        perror(""Error opening non-flat source file"");
        return;
    }

    int nonFlatDestinationFd = open(nonFlatDestinationFilename, O_WRONLY | O_CREAT, 0666);
    if (nonFlatDestinationFd < 0) {
        perror(""Error opening non-flat destination file"");
        close(nonFlatSourceFd);
        return;
    }

    int res;
    do {
        res = pread(nonFlatSourceFd, buf, sizeof(buf), nonFlatOffset);
        if (res <= 0) {
            break;
        }

        if (pwrite(nonFlatDestinationFd, buf, res, nonFlatOffset) < 0) {
            perror(""Error writing to non-flat destination file"");
            break;
        }

        nonFlatOffset += res;
    } while (res == sizeof(buf));

    close(nonFlatSourceFd);
    close(nonFlatDestinationFd);

    time_t endedAt = time(NULL);
    printf(""Non-Flat Copying Done! in %ld seconds\\n"", (endedAt - startedAt));
}

void runDestinationVM() {
    char storageCommandBuffer[500], destinationChangeUUIDCommand[500];

    time_t startedAt = time(NULL);

    sprintf(destinationChangeUUIDCommand, ""VBoxManage internalcommands sethduuid \\""%s\\"""", nonFlatDestinationFilename);
    sprintf(storageCommandBuffer, ""VBoxManage storageattach Destination --medium \\""%s\\"" --storagectl \\""IDE\\"" --port 0 --device 0 --type hdd"", nonFlatDestinationFilename);

    system(destinationChangeUUIDCommand);
    system(storageCommandBuffer);

    time_t endedAt = time(NULL);
    printf(""Running Destination in %ld seconds\\n"", (endedAt - startedAt));
}

void *sendOffset(void *recvConnection) {
    int connection = (intptr_t)recvConnection;
    char offsetBuffer[50];
    char clientMessage[2000];

    do {
        memset(offsetBuffer, 0, sizeof(offsetBuffer));
        memset(clientMessage, 0, sizeof(clientMessage));

        recv(connection, clientMessage, sizeof(clientMessage), 0);

        if (!copyingDone) {
            pthread_mutex_lock(&offsetMutex);

            sprintf(offsetBuffer, ""%zu"", offset);
            sendMessage(connection, offsetBuffer);

            recv(connection, clientMessage, sizeof(clientMessage), 0);
            pthread_mutex_unlock(&offsetMutex);
        } else {
            if (strcmp(clientMessage, ""SUSPENDING"") != 0) {
                strcpy(offsetBuffer, ""DONE"");
                sendMessage(connection, offsetBuffer);
            }
        }
    } while (strcmp(clientMessage, ""CLOSE"") != 0);

    close(connection);
    printf(""\\tConnection Closed\\n"");

    copyNonFlatFile();
    runDestinationVM();

    pthread_exit(NULL);
}

void connectionHandler(int connection) {
    pthread_t thread;
    pthread_create(&thread, NULL, sendOffset, (void *)(intptr_t)connection);
}

void *runServer(void *arg) {
    createServer(connectionHandler);
    pthread_exit(NULL);
}

void getVMsInfo(int debugMode) {
    if (debugMode) {
        strcpy(sourceFilename, ""/path/to/source-flat.vmdk"");
        strcpy(nonFlatSourceFilename, ""/path/to/source.vmdk"");
        strcpy(destinationFilename, ""/path/to/destination-flat.vmdk"");
        strcpy(nonFlatDestinationFilename, ""/path/to/destination.vmdk"");
    } else {
        printf(""Source File Path: "");
        fgets(sourceFilename, sizeof(sourceFilename), stdin);
        printf(""Source File Path (non-flat): "");
        fgets(nonFlatSourceFilename, sizeof(nonFlatSourceFilename), stdin);
        printf(""Destination File Path (Will be created automatically): "");
        fgets(destinationFilename, sizeof(destinationFilename), stdin);
        printf(""Destination File Path (non-flat) (Will be created automatically): "");
        fgets(nonFlatDestinationFilename, sizeof(nonFlatDestinationFilename), stdin);

        sourceFilename[strcspn(sourceFilename, ""\\n"")] = 0;
        nonFlatSourceFilename[strcspn(nonFlatSourceFilename, ""\\n"")] = 0;
        destinationFilename[strcspn(destinationFilename, ""\\n"")] = 0;
        nonFlatDestinationFilename[strcspn(nonFlatDestinationFilename, ""\\n"")] = 0;
    }
}

int main() {
    pthread_t copyWorkerThread, serverThread;

    getVMsInfo(1);

    pthread_create(&copyWorkerThread, NULL, copyWorker, NULL);
    pthread_create(&serverThread, NULL, runServer, NULL);

    pthread_join(copyWorkerThread, NULL);
    pthread_join(serverThread, NULL);

    printf(""Done!\\n"");
    return 0;
}

",0
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <math.h>
#include <sys/time.h>
#include <string.h>

// Global variables
pthread_mutex_t minimum_value_lock;
long int partial_list_size;
int minimum_value;
long int *list;
long int NumElements, CLASS_SIZE;
int NumThreads;

void *find_min(void *) ;

pthread_mutex_t minimum_value_lock;

long int partial_list_size;
int minimum_value;
long int *list;
long int NumElements, CLASS_SIZE;
int NumThreads;

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

        pthread_t *threads;
        pthread_attr_t pta;
        int iteration,THREADS,ret_count;
        double time_start, time_end;
        struct timeval tv;
        struct timezone tz;
        double MemoryUsed = 0.0;
 char * CLASS;

        int counter;
        printf(""\\n\\t\\t--------------------------------------------------------------------------"");
        printf(""\\n\\t\\t Centre for Development of Advanced Computing (C-DAC)"");
        printf(""\\n\\t\\t C-DAC Multi Core Benchmark Suite 1.0"");
        printf(""\\n\\t\\t Email : RarchK"");
        printf(""\\n\\t\\t---------------------------------------------------------------------------"");
        printf(""\\n\\t\\t Objective : Sorting Single Dimension Array (Integer Operations)\\n "");
        printf(""\\n\\t\\t Performance of Sorting a Minimum value in a large Single Dimension Array "");
        printf(""\\n\\t\\t on Multi Socket Multi Core Processor using 1/2/4/8 threads \\n"");
        printf(""\\n\\t\\t..........................................................................\\n"");

         if( argc != 3 ){

            printf(""\\t\\t Very Few Arguments\\n "");
            printf(""\\t\\t Syntax : exec <Class-Size> <Threads>\\n"");
            exit(-1);
         }
         else {
            CLASS = argv[1];
            THREADS = atoi(argv[2]);
         }
         if( strcmp(CLASS, ""A"" )==0){
            CLASS_SIZE = 10000000;
         }
         if( strcmp(CLASS, ""B"" )==0){
            CLASS_SIZE = 100000000;
         }
        if( strcmp(CLASS, ""C"" )==0){
            CLASS_SIZE = 1000000000;
        }

        NumElements = CLASS_SIZE;
        NumThreads = THREADS;
        printf(""\\n\\t\\t Array Size  :  %ld"",NumElements);
        printf(""\\n\\t\\t Threads     :  %d"",NumThreads);
        printf(""\\n"");

        if (NumThreads < 1 )
        {
           printf(""\\n Number of threads must be greater than zero. Aborting ...\\n"");
           return 0;
        }

        if ((NumThreads != 1) && (NumThreads != 2) && (NumThreads != 4) && (NumThreads != 8))
        {
           printf(""\\n Number of Threads must be 1 or 2 or 4 or 8. Aborting ...\\n"");
           return 0;
        }

        if ( ( NumElements % NumThreads ) != 0 )
        {
           printf(""\\n Number of threads not a factor of Integer List size. Aborting.\\n"");
     return 0 ;
        }


        partial_list_size = NumElements / NumThreads;

        list = (long int *)malloc(sizeof(long int) * NumElements);
        MemoryUsed += ( NumElements * sizeof(long int));

        gettimeofday(&tv, &tz);
        time_start = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;

        for(counter = 0 ; counter < NumElements ; counter++){
            srand48((unsigned int)NumElements);
            list[counter] = (rand()%1000)+1.0;
        }

        threads = (pthread_t *)malloc(sizeof(pthread_t)*NumThreads);

        minimum_value = list[0];

        ret_count=pthread_mutex_init(&minimum_value_lock, 0);
     if(ret_count)
     {
  printf(""\\n ERROR : Return code from pthread_mutex_init() is %d "",ret_count);
  exit(-1);
     }

        ret_count=pthread_attr_init(&pta);
     if(ret_count)
     {
  printf(""\\n ERROR : Return code from pthread_attr_init() is %d "",ret_count);
  exit(-1);
     }

        pthread_attr_setscope(&pta,PTHREAD_SCOPE_SYSTEM);

        for(counter = 0 ; counter < NumThreads ; counter++)
 {
           ret_count=pthread_create(&threads[counter],&pta,(void *(*) (void *)) find_min,(void *) (counter+1));
        if(ret_count)
        {
  printf(""\\n ERROR : Return code from pthread_create() is %d "",ret_count);
  exit(-1);
        }
 }

        for(counter = 0 ; counter < NumThreads ; counter++)
 {
           ret_count=pthread_join(threads[counter],0);
        if(ret_count)
        {
  printf(""\\n ERROR : Return code from pthread_join() is %d "",ret_count);
  exit(-1);
        }
        }
        ret_count=pthread_attr_destroy(&pta);
     if(ret_count)
     {
  printf(""\\n ERROR : Return code from pthread_attr_destroy() is %d "",ret_count);
  exit(-1);
     }

        gettimeofday(&tv, &tz);
        time_end = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;

        printf(""\\n\\t\\t Minimum Value found in the Integer list     :  %d"",minimum_value);
        printf(""\\n\\t\\t Memory Utilised                             :  %lf MB"",(MemoryUsed / (1024*1024)));
        printf(""\\n\\t\\t Time Taken in Seconds  (T)                  :  %lf Seconds"",( time_end - time_start));
        printf(""\\n\\t\\t..........................................................................\\n"");


        free(list);
        free(threads);
        return 0;

 }
 void *find_min(void * myid ) {

     int my_min;
     long int counter;

     int myId = (int)myid;

     my_min = list[(myId-1)*partial_list_size];

     for (counter = ((myId - 1) * partial_list_size); counter <= ((myId * partial_list_size) - 1); counter++){
        if (list[counter] < my_min)
            my_min = list[counter];
     }




    pthread_mutex_lock(&minimum_value_lock) ;
    if (my_min < minimum_value)
       minimum_value = my_min;


    pthread_mutex_unlock(&minimum_value_lock) ;

    pthread_exit(0);
}
",1
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/stat.h>
#include <errno.h>


static char *root;
static int workers;
static int trials;
static int record_absolute;
static struct timeval asbolute_start;

static pthread_mutex_t worker_sync_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t worker_sync_cond = PTHREAD_COND_INITIALIZER;
static volatile int worker_sync_t = -1;
static volatile int workers_alive = 0;

int timeval_subtract(struct timeval *result, struct timeval *x,
                     struct timeval *y) {
    if(x->tv_usec < y->tv_usec) {
        int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
        y->tv_usec -= 1000000 * nsec;
        y->tv_sec += nsec;
    }
    if(x->tv_usec - y->tv_usec > 1000000) {
        int nsec = (x->tv_usec - y->tv_usec) / 1000000;
        y->tv_usec += 1000000 * nsec;
        y->tv_sec -= nsec;
    }

    result->tv_sec = x->tv_sec - y->tv_sec;
    result->tv_usec = x->tv_usec - y->tv_usec;

    return x->tv_sec < y->tv_sec;
}

static void pthread_usleep(unsigned int usecs) {
    int result;
    pthread_cond_t timercond = PTHREAD_COND_INITIALIZER;
    pthread_mutex_t timerlock = PTHREAD_MUTEX_INITIALIZER;
    struct timespec timerexpires;

    clock_gettime(CLOCK_REALTIME, &timerexpires);
    timerexpires.tv_nsec += usecs * 1000;
    if(timerexpires.tv_nsec >= 1000000000) {
        timerexpires.tv_sec += timerexpires.tv_nsec / 1000000000;
        timerexpires.tv_nsec = timerexpires.tv_nsec % 1000000000;
    }

    pthread_mutex_lock(&timerlock);
    result = ~ETIMEDOUT;
    while(result != ETIMEDOUT)
        result = pthread_cond_timedwait(&timercond, &timerlock, &timerexpires);
    pthread_mutex_unlock(&timerlock);
}

void *worker_run(void *data) {
    int id = (int) data;

    char clkpath[256];
    sprintf(clkpath, ""%s/clock"", root);

    int clkfd = open(clkpath, O_RDONLY);
    if(clkfd < 0) {
        perror(""open"");
        exit(1);
    }

    char testpath[256];
    sprintf(testpath, ""%s/%d"", root, id);

    int fd = open(testpath, O_RDWR | O_CREAT, 0777);
    if(fd < 0) {
        perror(""open"");
        exit(1);
    }

    char buf[1024];
    memset(buf, 'x', sizeof(buf));
    ((int *) buf)[0] = id;

    uint64_t *deltas = malloc(sizeof(uint64_t) * trials * 2);

    pthread_mutex_lock(&worker_sync_lock);
    workers_alive++;
    pthread_mutex_unlock(&worker_sync_lock);


    if(id == 0) {
        while(workers_alive < workers)
            pthread_usleep(100000);

        struct stat statbuf;
        if(fstat(clkfd, &statbuf) < 0) {
            perror(""fstat"");
            exit(1);
        }
    }

    int t;
    for(t = 0; ; t++) {
        if(id == 0) {
            if(t >= trials && workers_alive == 1)
                break;
        } else {
            if(t >= trials)
                break;

            pthread_mutex_lock(&worker_sync_lock);
            while(worker_sync_t < t)
                pthread_cond_wait(&worker_sync_cond, &worker_sync_lock);
            pthread_mutex_unlock(&worker_sync_lock);
        }

        struct timeval before;
        gettimeofday(&before, 0);

        if(lseek(fd, 0, 0) < 0) {
            perror(""lseek"");
            exit(1);
        }
        if(write(fd, buf, sizeof(buf)) < 0) {
            perror(""write"");
            exit(1);
        }

        struct timeval after;
        gettimeofday(&after, 0);

        struct timeval diff;
        if(record_absolute)
            timeval_subtract(&diff, &after, &asbolute_start);
        else
            timeval_subtract(&diff, &after, &before);

        deltas[t] = (diff.tv_sec * 1000000) + diff.tv_usec;

        if(id == 0) {
            pthread_mutex_lock(&worker_sync_lock);
            worker_sync_t = t;
            pthread_cond_broadcast(&worker_sync_cond);
            pthread_mutex_unlock(&worker_sync_lock);

            pthread_usleep(49000);
        }
    }

    pthread_mutex_lock(&worker_sync_lock);
    workers_alive--;
    pthread_mutex_unlock(&worker_sync_lock);

    return deltas;
}

int main(int argc, char *argv[]) {
    if(argc < 4 || argc > 5) {
        printf(""Usage: concurio [mount-point] [workers] [trials] [-a]\\n"");
        exit(1);
    }

    root = argv[1];
    workers = strtol(argv[2], 0, 10);
    trials = strtol(argv[3], 0, 10);
    if(argc == 5 && strcmp(argv[4], ""-a"") == 0)
        record_absolute = 1;
    else
        record_absolute = 0;

    gettimeofday(&asbolute_start, 0);

    pthread_t *worker_threads = malloc(sizeof(pthread_t) * workers);

    int w;
    for(w = 0; w < workers; w++)
        pthread_create(&worker_threads[w], 0, worker_run, (void *) w);

    uint64_t **worker_deltas = malloc(sizeof(uint64_t *) * workers);
    for(w = 0; w < workers; w++)
        pthread_join(worker_threads[w], (void **) &worker_deltas[w]);

    if(record_absolute)
        printf(""absolute\\n"");
    else
        printf(""write-time\\n"");

    int t;
    for(w = 0; w < workers; w++) {
        for(t = 0; t < trials; t++)
            printf(""%d: %llu\\n"", w, worker_deltas[w][t]);
        free(worker_deltas[w]);
    }

    exit(0);
}
",0
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>

// Global variables
static int hash_index;
static char buffer_postdata[1024 * 1024 * 100];
// 
static void analysis_web_from_job(struct Job *current_job);
static void analysis_web_from_http_list(struct Http_List *list,time_t current_time,
     struct tuple4 addr);
static void analysis_web_from_http(struct Http *http,time_t current_time,
       struct tuple4 addr);
static void process_function_actual(int job_type);
static int process_judege(struct Job *job);
static void *process_function(void *);

static int hash_index;
static char buffer_postdata[1024*1024*100];

static void analysis_web_from_job(struct Job *current_job){

    struct Http_RR *http_rr = current_job->http_rr;

    if(http_rr == 0)
        return;

    analysis_web_from_http_list(http_rr->request_list,current_job->time,
    current_job->ip_and_port);
    analysis_web_from_http_list(http_rr->response_list,current_job->time,
    current_job->ip_and_port);
}

static void analysis_web_from_http_list(struct Http_List *list,time_t current_time,
     struct tuple4 addr){

    if(list == 0)
        return;

    struct Http * point = list->head;
    while(point != 0){

         analysis_web_from_http(point,current_time, addr);
         point = point->next;
    }
}

static void analysis_web_from_http(struct Http *http,time_t current_time,
       struct tuple4 addr){

     if(http->type != PATTERN_REQUEST_HEAD)
         return;

     struct WebInformation webinfo;
     webinfo.request = http->method;
     webinfo.host = http->host;
     webinfo.url = http->uri;
     webinfo.referer = http->referer;
     webinfo.time = current_time;
     webinfo.data_length = 0;
     webinfo.data_type = 0;
     webinfo.data = 0;

     strcpy(webinfo.srcip, int_ntoa(addr.saddr));
     strcpy(webinfo.dstip, int_ntoa(addr.daddr));

     char segment[] = ""\\n"";

     if(strstr(webinfo.request,""POST"")!= 0){

         int length = 0;
         struct Entity_List *entity_list;
         struct Entity *entity;

         entity_list = http->entity_list;
         if(entity_list != 0){
             entity = entity_list->head;
             while(entity != 0){

                if(entity->entity_length <= 0 || entity->entity_length > 1024*1024*100){
                       entity = entity->next;
                       continue;
                }

               length += entity->entity_length;
               length += 1;
               entity = entity->next;
             }
         }


         if(length > 1 && length < 1024*1024*100){

              memset(buffer_postdata,0,length+1);

              entity_list = http->entity_list;


              if(entity_list != 0){

                  entity = entity_list->head;
                  while(entity != 0){
                       if(entity->entity_length <= 0 || entity->entity_length > 1024*1024*100){
                               entity = entity->next;
                               continue;
                        }
                        memcpy(buffer_postdata + length,entity->entity_content,entity->entity_length);
                        length += entity->entity_length;

                        memcpy(buffer_postdata + length,segment,1);
                        length += 1;
                        entity = entity->next;
                  }
              }
              webinfo.data_length = length;
              webinfo.data_type = """";
              webinfo.data = buffer_postdata;
        }

     }

     sql_factory_add_web_record(&webinfo,hash_index);
}

static void *process_function(void *arg){
   int job_type = JOB_TYPE_WEB;
   while(1){
       pthread_mutex_lock(&(job_mutex_for_cond[job_type]));
       pthread_cond_wait(&(job_cond[job_type]),&(job_mutex_for_cond[job_type]));
       pthread_mutex_unlock(&(job_mutex_for_cond[job_type]));

       process_function_actual(job_type);
    }
    return 0;
}

static void process_function_actual(int job_type){
   struct Job_Queue private_jobs;
   private_jobs.front = 0;
   private_jobs.rear = 0;
   get_jobs(job_type,&private_jobs);
   struct Job current_job;

   while(!jobqueue_isEmpty(&private_jobs)){

       jobqueue_delete(&private_jobs,&current_job);
       hash_index = current_job.hash_index;
       analysis_web_from_job(&current_job);
       if(current_job.http_rr != 0)
          free_http_rr(current_job.http_rr);
   }
}

static int process_judege(struct Job *job){
   return 1;
}

extern void web_analysis_init(){
    register_job(JOB_TYPE_WEB,process_function,process_judege,CALL_BY_HTTP_ANALYSIS);
}
",1
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <errno.h>

enum mode {
 MODE_MB,
 MODE_MEMBARRIER,
 MODE_COMPILER_BARRIER,
 MODE_MEMBARRIER_MISSING_REGISTER,
};

enum mode mode;

struct map_test {
 int x, y;
 int ref;
 int r2, r4;
 int r2_ready, r4_ready;
 int killed;
 pthread_mutex_t lock;
};

static void check_parent_regs(struct map_test *map_test, int r2)
{
 pthread_mutex_lock(&map_test->lock);
 if (map_test->r4_ready) {
  if (r2 == 0 && map_test->r4 == 0) {
   fprintf(stderr, ""Error detected!\\n"");
   CMM_STORE_SHARED(map_test->killed, 1);
   abort();
  }
  map_test->r4_ready = 0;
  map_test->x = 0;
  map_test->y = 0;
 } else {
  map_test->r2 = r2;
  map_test->r2_ready = 1;
 }
 pthread_mutex_unlock(&map_test->lock);
}

static void check_child_regs(struct map_test *map_test, int r4)
{
 pthread_mutex_lock(&map_test->lock);
 if (map_test->r2_ready) {
  if (r4 == 0 && map_test->r2 == 0) {
   fprintf(stderr, ""Error detected!\\n"");
   CMM_STORE_SHARED(map_test->killed, 1);
   abort();
  }
  map_test->r2_ready = 0;
  map_test->x = 0;
  map_test->y = 0;
 } else {
  map_test->r4 = r4;
  map_test->r4_ready = 1;
 }
 pthread_mutex_unlock(&map_test->lock);
}

static void loop_parent(struct map_test *map_test)
{
 int i, r2;

 for (i = 0; i < 100000000; i++) {
  uatomic_inc(&map_test->ref);
  while (uatomic_read(&map_test->ref) < 2 * (i + 1)) {
   if (map_test->killed)
    abort();
   caa_cpu_relax();
  }
  CMM_STORE_SHARED(map_test->x, 1);
  switch (mode) {
  case MODE_MB:
   cmm_smp_mb();
   break;
  case MODE_MEMBARRIER:
  case MODE_MEMBARRIER_MISSING_REGISTER:
   if (-ENOSYS) {
    perror(""membarrier"");
    CMM_STORE_SHARED(map_test->killed, 1);
    abort();
   }
   break;
  case MODE_COMPILER_BARRIER:
   cmm_barrier();
   break;
  }
  r2 = CMM_LOAD_SHARED(map_test->y);
  check_parent_regs(map_test, r2);
 }
}

static void loop_child(struct map_test *map_test)
{
 int i, r4;

 switch (mode) {
 case MODE_MEMBARRIER:
  if (-ENOSYS) {
   perror(""membarrier"");
   CMM_STORE_SHARED(map_test->killed, 1);
   abort();
  }
  break;
 default:
  break;
 }
 for (i = 0; i < 100000000; i++) {
  uatomic_inc(&map_test->ref);
  while (uatomic_read(&map_test->ref) < 2 * (i + 1)) {
   if (map_test->killed)
    abort();
   caa_cpu_relax();
  }

  CMM_STORE_SHARED(map_test->y, 1);
  switch (mode) {
  case MODE_MB:
   cmm_smp_mb();
   break;
  case MODE_MEMBARRIER:
  case MODE_MEMBARRIER_MISSING_REGISTER:

   cmm_barrier();
   break;
  case MODE_COMPILER_BARRIER:
   cmm_barrier();
   break;
  }
  r4 = CMM_LOAD_SHARED(map_test->x);
  check_child_regs(map_test, r4);
 }
}

void print_arg_error(void)
{
 fprintf(stderr, ""Please specify test mode: <m>: paired mb, <s>: sys-membarrier, <c>: compiler barrier (error), <n>: sys-membarrier with missing registration (error).\\n"");
}

int main(int argc, char **argv)
{
 char namebuf[PATH_MAX];
 pid_t pid;
 int fd, ret = 0;
 void *buf;
 struct map_test *map_test;
 pthread_mutexattr_t attr;

 if (argc < 2) {
  print_arg_error();
  return -1;
 }
 if (!strcmp(argv[1], ""-m"")) {
  mode = MODE_MB;
 } else if (!strcmp(argv[1], ""-s"")) {
  mode = MODE_MEMBARRIER;
 } else if (!strcmp(argv[1], ""-c"")) {
  mode = MODE_COMPILER_BARRIER;
 } else if (!strcmp(argv[1], ""-n"")) {
  mode = MODE_MEMBARRIER_MISSING_REGISTER;
 } else {
  print_arg_error();
  return -1;
 }

 buf = mmap(0, 4096, PROT_READ | PROT_WRITE,
   MAP_ANONYMOUS | MAP_SHARED, -1, 0);
 if (buf == MAP_FAILED) {
  perror(""mmap"");
  ret = -1;
  goto end;
 }
 map_test = (struct map_test *)buf;
 pthread_mutexattr_init(&attr);
 pthread_mutexattr_setpshared(&attr, 1);
 pthread_mutex_init(&map_test->lock, &attr);
 pid = fork();
 if (pid < 0) {
  perror(""fork"");
  ret = -1;
  goto unmap;
 }
 if (!pid) {

  loop_child(map_test);
  return 0;
 }

 loop_parent(map_test);
 pid = waitpid(pid, 0, 0);
 if (pid < 0) {
  perror(""waitpid"");
  ret = -1;
 }
unmap:
 pthread_mutex_destroy(&map_test->lock);
 pthread_mutexattr_destroy(&attr);
 if (munmap(buf, 4096)) {
  perror(""munmap"");
  ret = -1;
 }
end:
 return ret;
}
",0
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <sched.h>
#include <string.h>

typedef enum _color {
  ZERO = 0,
  BLUE = 1,
  RED = 2,
  YELLOW = 3,
  INVALID = 4,
} color;

char *colors[] = { ""zero"",
     ""blue"",
     ""red"",
     ""yellow"",
         ""invalid""
};

char *digits[] = { ""zero"", ""one"", ""two"", ""three"", ""four"", ""five"",
     ""six"", ""seven"", ""eight"", ""nine""
};

sem_t at_most_two;
sem_t mutex;
sem_t sem_priv;
sem_t sem_print;

pthread_mutex_t print_mutex;

int meetings_left = 0;
int first_arrived = 0;
int done = 0;

typedef struct _creature {
  color my_color;
  pthread_t id;
  int number_of_meetings;
} chameos;

chameos A;
chameos B;

static color
compliment_color(color c1, color c2) {
  color result;

  switch(c1) {
  case BLUE:
    switch(c2) {
    case BLUE:
      result = BLUE;
      break;
    case RED:
      result = YELLOW;
      break;
    case YELLOW:
      result = RED;
      break;
    default:
      printf(""error complementing colors: %d, %d\\n"", c1, c2);
      exit(1);
    }
    break;
  case RED:
    switch(c2) {
    case BLUE:
      result = YELLOW;
      break;
    case RED:
      result = RED;
      break;
    case YELLOW:
      result = BLUE;
      break;
    default:
      printf(""error complementing colors: %d, %d\\n"", c1, c2);
      exit(2);
    }
    break;
  case YELLOW:
    switch(c2) {
    case BLUE:
      result = RED;
      break;
    case RED:
      result = BLUE;
      break;
    case YELLOW:
      result = YELLOW;
      break;
    default:
      printf(""error complementing colors: %d, %d\\n"", c1, c2);
      exit(3);
    }
    break;
  default:
    printf(""error complementing colors: %d, %d\\n"", c1, c2);
    exit(4);
  }
  return result;
}

static void
spell_the_number(int prefix, int number) {
  char *string_number;
  int string_length;
  int i;
  int digit;
  int output_so_far = 0;
  char buff[1024];

  if(prefix != -1) {
    output_so_far = sprintf(buff, ""%d"", prefix);
  }

  string_number = malloc(sizeof(char)*10);
  string_length = sprintf(string_number, ""%d"", number);
  for(i = 0; i < string_length; i++) {
    digit = string_number[i] - '0';
    output_so_far += sprintf(buff+output_so_far, "" %s"", digits[digit]);
  }
  printf(""%s\\n"",buff);

}

static chameos *
meeting(chameos c) {
  chameos *other_critter;
  other_critter = malloc(sizeof(chameos));

  sem_wait(&at_most_two);
  if(done == 1) {
    sem_post(&at_most_two);
    return 0;
  }

  sem_wait(&mutex);
  if(done == 1) {
    sem_post(&mutex);
    sem_post(&at_most_two);
    return 0;
  }

  if(first_arrived == 0) {
    first_arrived = 1;

    A.my_color = c.my_color;
    A.id = c.id;

    sem_post(&mutex);
    sem_wait(&sem_priv);

    other_critter->my_color = B.my_color;
    other_critter->id = B.id;

    meetings_left--;
    if(meetings_left == 0) {
      done = 1;
    }

    sem_post(&mutex);
    sem_post(&at_most_two); sem_post(&at_most_two);
  } else {
    first_arrived = 0;

    B.my_color = c.my_color;
    B.id = c.id;

    other_critter->my_color = A.my_color;
    other_critter->id = A.id;

    sem_post(&sem_priv);
  }

  return other_critter;
}

static void *
creature(void *arg) {
  chameos critter;
  critter.my_color = (color)arg;
  critter.id = pthread_self();
  critter.number_of_meetings = 0;

  chameos *other_critter;

  int met_others = 0;
  int met_self = 0;
  int *total_meetings = 0;

  while(done != 1) {
    other_critter = meeting(critter);

    if(other_critter == 0) {
      break;
    }

    if(critter.id == other_critter->id) {
      met_self++;
    }else{
      met_others++;
    }

    critter.my_color = compliment_color(critter.my_color, other_critter->my_color);
    free(other_critter);
  }

  sem_wait(&sem_print);
  
  spell_the_number(met_others + met_self, met_self);
  

  total_meetings = malloc(sizeof(int));
  *total_meetings =met_others + met_self;

  pthread_exit((void *)total_meetings);
}

void
print_colors(void) {
  int i, j;
  color c;

  for(i = 1; i < INVALID; i++) {
    for(j = 1; j < INVALID; j++) {
      c = compliment_color(i,j);
      printf(""%s + %s -> %s\\n"",colors[i],colors[j], colors[c]);
    }
  }
  printf(""\\n"");
}





void
run_the_meetings(color *starting_colors, int n_colors, int total_meetings_to_run) {
   struct sched_param priority;
   priority.sched_priority = 1;

   pthread_t pid_tab[10];
   memset(pid_tab, 0, sizeof(pthread_t)*10);

   int i;
   int total = 0;
   void *rslt = 0;

   sem_init(&at_most_two, 0, 2);
   sem_init(&mutex, 0, 1);
   sem_init(&sem_priv, 0, 0);
   sem_init(&sem_print, 0, 0);

   pthread_mutex_init(&print_mutex, 0);

   meetings_left = total_meetings_to_run;
   first_arrived = 0;
   done = 0;

   sched_setscheduler(0, SCHED_FIFO, &priority);

   for(i = 0; i < n_colors; i++) {
      printf("" %s"", colors[starting_colors[i]]);
      pthread_create(&pid_tab[i], 0, &creature, (void *)starting_colors[i]);
   }
   printf(""\\n"");
   for(i = 0; i < n_colors; i++) {
      sem_post(&sem_print);
   }

   for(i = 0; i < n_colors; i++) {
      pthread_join(pid_tab[i], &rslt);
      total += *(int *)rslt;
      free(rslt);
   }
   spell_the_number(-1, total);
   printf(""\\n"");
}

int
main(int argc, char **argv) {
   color first_generation[3] = { BLUE, RED, YELLOW };
   color second_generation[10] = {BLUE, RED, YELLOW, RED, YELLOW,
                   BLUE, RED, YELLOW, RED, BLUE};
   int number_of_meetings_to_run = 600;

   if(argc > 1) {
      number_of_meetings_to_run = strtol(argv[1], 0, 10);
   }

   print_colors();
   run_the_meetings(first_generation, 3, number_of_meetings_to_run);
   run_the_meetings(second_generation, 10, number_of_meetings_to_run);

   return 0;
}
",1
"/* File:  
 *    pth_pool.c
 *
 * Purpose:
 *    Implementação de um pool de threads
 *
 *
 * Compile:  gcc -g -Wall -o pth_pool pth_pool.c -lpthread -lrt
 * Usage:    ./pth_hello
 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h> 
#include <unistd.h>
#include <semaphore.h>
#include <time.h>

#define THREAD_NUM 4    // Tamanho do pool de threads
#define BUFFER_SIZE 256 // Númermo máximo de tarefas enfileiradas

typedef struct Task{
   int a, b;
}Task;

Task taskQueue[BUFFER_SIZE];
int taskCount = 0;

pthread_mutex_t mutex;

pthread_cond_t condFull;
pthread_cond_t condEmpty;

void executeTask(Task* task, int id){
   int result = task->a + task->b;
   printf(""(Thread %d) Sum of %d and %d is %d\\n"", id, task->a, task->b, result);
}

Task getTask(){
   pthread_mutex_lock(&mutex);
   
   while (taskCount == 0){
      pthread_cond_wait(&condEmpty, &mutex);
   }
   
   Task task = taskQueue[0];
   int i;
   for (i = 0; i < taskCount - 1; i++){
      taskQueue[i] = taskQueue[i+1];
   }
   taskCount--;
   
   pthread_mutex_unlock(&mutex);
   pthread_cond_signal(&condFull);
   return task;
}

void submitTask(Task task){
   pthread_mutex_lock(&mutex);

   while (taskCount == BUFFER_SIZE){
      pthread_cond_wait(&condFull, &mutex);
   }

   taskQueue[taskCount] = task;
   taskCount++;

   pthread_mutex_unlock(&mutex);
   pthread_cond_signal(&condEmpty);
}

void *startThread(void* args);  

/*--------------------------------------------------------------------*/
int main(int argc, char* argv[]) {
   pthread_mutex_init(&mutex, NULL);
   
   pthread_cond_init(&condEmpty, NULL);
   pthread_cond_init(&condFull, NULL);

   pthread_t thread[THREAD_NUM]; 
   long i;
   for (i = 0; i < THREAD_NUM; i++){  
      if (pthread_create(&thread[i], NULL, &startThread, (void*) i) != 0) {
         perror(""Failed to create the thread"");
      }  
   }
   
   srand(time(NULL));
   for (i = 0; i < 500; i++){
      Task t = {
         .a = rand() % 100,
         .b = rand() % 100
      };
      submitTask(t);
   }
   
   for (i = 0; i < THREAD_NUM; i++){  
      if (pthread_join(thread[i], NULL) != 0) {
         perror(""Failed to join the thread"");
      }  
   }
   
   pthread_mutex_destroy(&mutex);
   pthread_cond_destroy(&condEmpty);
   pthread_cond_destroy(&condFull);
   return 0;
}  /* main */

/*-------------------------------------------------------------------*/
void *startThread(void* args) {
    long id = (long) args;
    while (1) {
        Task task = getTask();
        if (task.a == -1 && task.b == -1) {  // Check for termination task
            printf(""(Thread %ld) Terminating\\n"", id);
            break;  // Exit the loop
        }
        executeTask(&task, id);
        sleep(rand() % 5);
    }
    return NULL;
}
",0
"/* Arquivo:  
 *    pth_condition_variable.c
 *
 * Propósito:
 *    Demonstrar Condition Variable em C
 *
 *
 * Compile:  gcc -g -Wall -o pth_condition_variable pth_condition_variable.c -lpthread -lrt
 * Usage:    ./pth_condition_variable 
 *
 */

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
 
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
 
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
int done = 1;
 
void* execute()
{
    
    if (done == 1) {
        done = 2;
        printf(""Esperando por cond1\\n"");
        pthread_cond_wait(&cond1, &lock);
    }
    else {
        printf(""Sinalizando cond1\\n"");
         // Unlock before signaling
        pthread_cond_signal(&cond1);
        return NULL; // Return immediately to avoid double unlocking
    }

    
    printf(""Fim da thread\\n"");

    return NULL;
}
 
int main()
{
    pthread_t tid1, tid2;
 
    pthread_create(&tid1, NULL, execute, NULL);
 
    sleep(5);
 
    pthread_create(&tid2, NULL, execute, NULL);
 
    pthread_join(tid2, NULL);
 
    return 0;
}
",1
"#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include<math.h>
int tickets = 20;
pthread_mutex_t mutex;

void *mythread1(void)
{
    while (1)
    {
        pthread_mutex_lock(&mutex);
        if (tickets > 0)
        {
            usleep(1000);
            printf(""ticketse1 sells ticket:%d\\n"", tickets--);
            pthread_mutex_unlock(&mutex);
        }
        else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
        sleep(1);
    }
    return (void *)0;
}
void *mythread2(void)
{
    while (1)
    {
        pthread_mutex_lock(&mutex);
        if (tickets > 0)
        {
            usleep(1000);
            printf(""ticketse2 sells ticket:%d\\n"", tickets--);
            pthread_mutex_unlock(&mutex);
        }
        else
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
        sleep(1);
    }
    return (void *)0;
}

int main(int argc, const char *argv[])
{
    //int i = 0;
    int ret = 0;
    pthread_t id1, id2;

    ret = pthread_create(&id1, NULL, (void *)mythread1, NULL);
    if (ret)
    {
        printf(""Create pthread error!\\n"");
        return 1;
    }

    ret = pthread_create(&id2, NULL, (void *)mythread2, NULL);
    if (ret)
    {
        printf(""Create pthread error!\\n"");
        return 1;
    }

    pthread_join(id1, NULL);
    pthread_join(id2, NULL);

    return 0;
}
",0
"/* Arquivo:  
 *    pth_mutex1.c
 *
 * Propósito:
 *    
 * Input:
 *    nenhum
 * Output:
 *
 * Compile:  gcc -g -Wall -o pth_mutex1 pth_mutex1.c -lpthread
 * Usage:    ./pth_mutex1 
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h> 
#include <unistd.h>
#include <string.h>
#include <time.h>


int publico = 0;

pthread_mutex_t mutex;

void incPublico(){
   
   publico++;
   
}

void *execute() {
   int i;

   for  (i = 1; i <= 100000; i++){
      incPublico();
   }
   return NULL;
} 


/*--------------------------------------------------------------------*/
int main(int argc, char* argv[]) {
   pthread_t t1, t2, t3, t4; 
   
   pthread_mutex_init(&mutex, NULL);

   // Criação e execução das threads
   pthread_create(&t1, NULL, execute, NULL);  
   pthread_create(&t2, NULL, execute, NULL);  
   pthread_create(&t3, NULL, execute, NULL);  
   pthread_create(&t4, NULL, execute, NULL);  
   
   // Espera pela finalização das threads
   pthread_join(t1, NULL); 
   pthread_join(t2, NULL); 
   pthread_join(t3, NULL); 
   pthread_join(t4, NULL); 

   printf(""Público final: %d\\n"", publico);
   pthread_mutex_destroy(&mutex);

   return 0;
}  /* main */


",1
"#include <stdio.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

struct employee {
	int 	number;
	int		id;
	char	first_name[32];
	char	last_name[32];
	char	department[32];
	int 	root_number;
};

/* employees在本程序中是只读的，所以不需要考虑同步问题 */
struct employee employees[] = {
	{ 1, 12345678, ""astro"", ""Bluse"", ""Accounting"", 101 },
	{ 2, 87654321, ""Shrek"", ""Charl"", ""Programmer"", 102 },
};

/* 本程序需要对employee_of_the_day这个全局变量修改，所以需要同步 */
struct employee employee_of_the_day;

void copy_employee(struct employee *from, struct employee *to)
{
	memcpy(to, from, sizeof(struct employee));
}

pthread_mutex_t	lock = PTHREAD_MUTEX_INITIALIZER;

void *do_loop(void *data)
{
	int num = *(int *)data;

	while (1) {
		pthread_mutex_lock(&lock);
		copy_employee(&employees[num - 1], &employee_of_the_day);
		pthread_mutex_unlock(&lock);
	}
}


int main(int argc, const char *argv[])
{
	pthread_t	th1, th2;
	int			num1 = 1;
	int 		num2 = 2;
	int 		i;

	copy_employee(&employees[0], &employee_of_the_day);

	if (pthread_create(&th1, NULL, do_loop, &num1)) {
		errx(EXIT_FAILURE, ""pthread_create() error.\\n"");
	}
	if (pthread_create(&th2, NULL, do_loop, &num2)) {
		errx(EXIT_FAILURE, ""pthread_create() error.\\n"");
	}

	while (1) {
		pthread_mutex_lock(&lock);
		struct employee *p = &employees[employee_of_the_day.number - 1];

		if (p->id != employee_of_the_day.id) {
			printf(""mismatching 'id', %d != %d (loop '%d')\\n"", 
								employee_of_the_day.id, p->id, i);
			exit(EXIT_FAILURE);
		}

		if (strcmp(p->first_name, employee_of_the_day.first_name)) {
			printf(""mismatching 'first_name', %s != %s (loop '%d')\\n"",
								employee_of_the_day.first_name, p->first_name, i);
			exit(EXIT_FAILURE);
		}

		if (strcmp(p->last_name, employee_of_the_day.last_name)) {
			printf(""mismatching 'last_name', %s != %s (loop '%d')\\n"",
								employee_of_the_day.last_name, p->last_name, i);
			exit(EXIT_FAILURE);
		}

		if (strcmp(p->department, employee_of_the_day.department)) {
			printf(""mismatching 'department', %s != %s (loop '%d')\\n"",
								employee_of_the_day.department, p->department, i);
			exit(EXIT_FAILURE);
		}

		if (p->root_number != employee_of_the_day.root_number) {
			printf(""mismatching 'root_number', %d != %d (loop '%d')\\n"", 
								employee_of_the_day.root_number, p->root_number, i);
			exit(EXIT_FAILURE);
		}
		
		printf(""lory, employees contents was always consistent\\n"");
		pthread_mutex_unlock(&lock);
	}
		
	exit(EXIT_SUCCESS);
}
",0
"#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <math.h>

#define NUM_THREADS 2			/* default number of threads	*/

/* Shared global variables. All threads can access them.	  	*/
float hypotenuse;
pthread_mutex_t mutexsum;


void *square_side (void *);


int main (int argc, char **argv)
{
  int i;				/* loop variable		*/
  float sides[2];			/* right-angled triangle sides	*/
  pthread_t *thr_ids;			/* array of thread ids		*/

  switch (argc)				/* check command line arguments	*/
  {
    case 3:
      /* Get the values of the right-angled triangle sides		*/
      sides[0] = atof (argv[1]);
      sides[1] = atof (argv[2]);
      if ((sides[0] < 1) || (sides[1] < 1))
      {
	fprintf (stderr, ""Error: wrong values for triangle sides.\\n""
		 ""Usage:\\n""
		 ""  %s <side_a> <side_b>\\n""
		 ""values of sizes should be > 0\\n"",
		 argv[0]);
	exit (EXIT_FAILURE);
      }
      break;

    default:
      fprintf (stderr, ""Error: wrong number of parameters.\\n""
	       ""Usage:\\n""
	       ""  %s <side_a> <side_b>\\n"",
	       argv[0]);
      exit (EXIT_FAILURE);
  }
  
  /* allocate memory for all dynamic data structures			*/
  thr_ids = (pthread_t *) malloc (NUM_THREADS * sizeof (pthread_t));
  
  /* Validate that memory was successfully allocated			*/
  if (thr_ids == NULL)
  {
    fprintf (stderr, ""File: %s, line %d: Can't allocate memory."",
	     __FILE__, __LINE__);
    exit (EXIT_FAILURE);
  }
  
  printf (""\\nPythagoras' theorem | a^2 + b^2 = c^2 \\n""); 
  hypotenuse = 0;
  
  /* Initialize the mutex to protect share data (hypotenuse)		*/
  pthread_mutex_init (&mutexsum, NULL);
  
  /* Create the threads	and calculate the squares on the sides		*/
  pthread_create (&thr_ids[0], NULL, square_side, &sides[0]);
  pthread_create (&thr_ids[1], NULL, square_side, &sides[1]);
  
  /* Using join to syncronize the threads				*/
  for (i = 0; i < NUM_THREADS; i++)		
  {
    pthread_join (thr_ids[i], NULL);
  }
  
  printf (""Hypotenuse is %.2f\\n"", sqrt(hypotenuse)); 
  
  /* Deallocate any memory or resources associated			*/
  pthread_mutex_destroy (&mutexsum);
  free (thr_ids);
  
  return EXIT_SUCCESS;
}


/* square_side runs as a thread and calculates the areas of the 
 * square on the side, then sums the value to the hypotenuse.
 * It uses a mutex to protect the hypotenuse and avoid a race
 * conditiong within the threads.
 *
 * Input:		arg		pointer to triangle side value
 * Return value:	none
 *
 */
void *square_side (void *arg)
{
  float side;

  /* Get the value of the triangle side	and print the square 		*/
  side = *( ( float* )arg );
  printf (""%.2f^2 = %.2f\\n"", side, side * side); 
  
  /* Mutex lock/unlock to safely update the value of hypotenuse		*/
  pthread_mutex_lock (&mutexsum);
  hypotenuse += side * side;
  pthread_mutex_unlock (&mutexsum);
  
  pthread_exit (EXIT_SUCCESS);		/* Terminate the thread		*/
}
",1
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <sys/time.h>
#include <math.h>

#define GRID_SIZE 16384

float** main_plate;
float** main_prev_plate;
char** main_locked_cells;

pthread_barrier_t barrier_first;
pthread_barrier_t barrier_second;
pthread_mutex_t critical_begin_end;
pthread_mutex_t runnable;

typedef struct arg_plate {
 int nthreads;
 int begin;
 int end;
} arg_plate_t;

double when() {
 struct timeval tp;
 gettimeofday(&tp, 0);
 return ((double)tp.tv_sec + (double)tp.tv_usec * 1e-6);
}


float** createPlate() {
 float** plate = (float**)malloc(16384 * sizeof(float*));
 int k;
 for (k = 0; k < 16384; k++) {
  plate[k] = (float*)malloc(16384 * sizeof(float));
 }
 return plate;
}
char** createCharPlate() {
 char** plate = (char**)malloc(16384 * sizeof(char*));
 int k;
 for (k = 0; k < 16384; k++) {
  plate[k] = (char*)malloc(16384 * sizeof(char));
 }
 return plate;
}
void copy(float** main, float** result) {
 int i,j;
 for (i = 0; i < 16384; i++) {
  for (j = 0; j < 16384; j++) {

   result[i][j] = main[i][j];
  }
 }
}

void initPlate(float** plate, float** prev_plate) {
 int i, j;
 for (i = 0; i < 16384; i++) {
  for (j = 0; j < 16384; j++) {
   if (i == 0 || j == 0 || j == 16384 -1) {
    plate[i][j] = 0;
    prev_plate[i][j] = 0;
    main_locked_cells[i][j] = '1';
   }
   else if (i == 16384 -1) {
    plate[i][j] = 100;
    prev_plate[i][j] = 100;
    main_locked_cells[i][j] = '1';

   }
   else if (i == 400 && j >= 0 && j <= 330) {
    plate[i][j] = 100;
    prev_plate[i][j] = 100;
    main_locked_cells[i][j] = '1';
   }
   else if (i == 200 && j == 500) {
    plate[i][j] = 100;
    prev_plate[i][j] = 100;
    main_locked_cells[i][j] = '1';
   }
   else {
    plate[i][j] = 50;
    prev_plate[i][j] = 50;
    main_locked_cells[i][j] = '0';
   }
  }
 }
 for (i = 0; i < 16384; i++) {
  if ((i % 20) == 0) {
   for (j = 0; j < 16384; j++) {
    plate[i][j] = 100;
    prev_plate[i][j] = 100;
    main_locked_cells[i][j] = '1';
   }
  }
 }
 for (j = 0; j < 16384; j++) {
  if ((j % 20) == 0) {
   for (i = 0; i < 16384; i++) {
    plate[i][j] = 0;
    prev_plate[i][j] = 0;
    main_locked_cells[i][j] = '1';
   }
  }
 }
}

void cleanupFloat(float** plate) {
 int i, j;
 for (i = 0; i < 16384; i++) {
  free(plate[i]);
 }
 free(plate);
}
void cleanupChar(char** plate) {
 int i, j;
 for (i = 0; i < 16384; i++) {
  free(plate[i]);
 }
 free(plate);
}

void* update_plate(void* plate_arguments) {
 for(;;) {
  pthread_barrier_wait(&barrier_first);

  arg_plate_t* plate_args = (arg_plate_t*)plate_arguments;

  pthread_mutex_lock(&runnable);
  int begin = plate_args->begin;
  int end = plate_args->end;
  pthread_mutex_unlock(&runnable);


  int i, j;
  for (i = begin; i < end; i++) {
   for (j = 0; j < 16384; j++) {
    if (main_locked_cells[i][j] == '0') {
     main_plate[i][j] = (main_prev_plate[i+1][j] + main_prev_plate[i][j+1] + main_prev_plate[i-1][j]
       + main_prev_plate[i][j-1] + 4 * main_prev_plate[i][j]) * 0.125;
    }
   }
  }

  pthread_barrier_wait(&barrier_second);
 }
}
char steady(float** current_plate) {
 int count = 0;
 int i, j;
 float main_diff = 0;
 for (i = 0; i < 16384; i++) {
  for (j = 0; j < 16384; j++) {
   if (main_locked_cells[i][j] == '0') {
    if (current_plate[i][j] > 50)
     count++;

    float diff = fabs(current_plate[i][j] - (current_plate[i+1][j] + current_plate[i-1][j]
       + current_plate[i][j+1] + current_plate[i][j-1]) * 0.25);
    if (diff > main_diff)
     main_diff = diff;
   }
  }
 }

 if (main_diff > 0.1)
  return (1);
 else
  return (0);
}

void allocateWorkload(int nthreads, int* begin_end) {
 int step = 16384 / nthreads;
 int i;
 int begin = 0;
 for (i = 0; i < nthreads*2; i++) {
  begin_end[i] = begin;

  begin = begin+step;
  i += 1;

  begin_end[i] = begin;
 }
}

int startUpdate(pthread_t* threads, int nthreads) {
 printf(""Updating plate to steady state\\n"");

 int iterations = 0;
 int* begin_end = (int*)malloc((nthreads*2) * sizeof(int));
 allocateWorkload(nthreads, begin_end);

 int i;
 int j;
 pthread_t worker[nthreads];
 arg_plate_t* plate_args;
 for (i = 0; i < nthreads; i++) {
  pthread_mutex_lock(&critical_begin_end);

  plate_args = (arg_plate_t*)malloc(sizeof(arg_plate_t));
  j = i * 2;
  plate_args->begin = begin_end[j];
  plate_args->end = begin_end[j+1];

  pthread_create(&worker[i], 0, &update_plate, (void*)plate_args);


  pthread_mutex_unlock(&critical_begin_end);
 }
 do {
  iterations++;
  printf(""Iteration: %d\\n"", iterations);

  pthread_barrier_wait(&barrier_first);
  pthread_barrier_wait(&barrier_second);

  copy(main_plate, main_prev_plate);

 } while(steady(main_plate));
 return iterations;
}


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

 double start = when();
 printf(""Starting time: %f\\n"", start);


 int nthreads = atoi(argv[1]);
 pthread_t threads[nthreads];


 main_plate = createPlate();
 main_prev_plate = createPlate();
 main_locked_cells = createCharPlate();


 initPlate(main_plate, main_prev_plate);


 pthread_barrier_init(&barrier_first,0,nthreads+1);
 pthread_barrier_init(&barrier_second,0,nthreads+1);
 pthread_mutex_init(&critical_begin_end,0);
 pthread_mutex_init(&runnable,0);


 int iterations = startUpdate(threads, nthreads);


 double end = when();
 printf(""\\nEnding time: %f\\n"", end);
 printf(""Total execution time: %f\\n"", end - start);
 printf(""Number of iterations: %d\\n\\n"", iterations);


 pthread_barrier_destroy(&barrier_first);
 pthread_barrier_destroy(&barrier_second);
 pthread_mutex_destroy(&critical_begin_end);
 pthread_mutex_destroy(&runnable);


 printf(""Cleanup\\n"");
 cleanupFloat(main_plate);
 cleanupFloat(main_prev_plate);
 cleanupChar(main_locked_cells);

 return 0;
}
",0
"#define _GNU_SOURCE /* To get pthread_getattr_np() declaration */
#include <assert.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void show_stack(pthread_attr_t *attr, pthread_t thread, char *prefix) {
  size_t stack_size, guard_size;
  void *stack_addr;
  int rc;

  rc = pthread_attr_getguardsize(attr, &guard_size);
  assert(rc == 0);

  rc = pthread_attr_getstack(attr, &stack_addr, &stack_size);
  assert(rc == 0);

  printf(""Thread %s (id=%lu) stack:\\n"", prefix, thread);
  printf(""\\tstart address\\t= %p\\n"", stack_addr);
  printf(""\\tend address\\t= %p\\n"", stack_addr + stack_size);
  printf(""\\tstack size\\t= %.2f MB\\n"", stack_size / 1024.0 / 1024.0);
  printf(""\\tguard size\\t= %lu B\\n"", guard_size);
}

void *entry_point(void *arg) {
  pthread_t thread = pthread_self();

  int rc;
  pthread_attr_t attr;
  rc = pthread_getattr_np(thread, &attr);
  assert(rc == 0);

  
  show_stack(&attr, thread, (char *)arg);
  

  return NULL;
}

int main(int argc, char *argv[]) {
  pthread_t p1, p2;
  int rc;

  rc = pthread_create(&p1, NULL, entry_point, ""1"");
  assert(rc == 0);
  rc = pthread_create(&p2, NULL, entry_point, ""2"");
  assert(rc == 0);

  entry_point(""main"");

  rc = pthread_join(p1, NULL);
  assert(rc == 0);
  rc = pthread_join(p2, NULL);
  assert(rc == 0);

  return 0;
}
",1
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

enum {
    QUEUE_BUF_SIZE = 100000,
};

typedef struct vector_s {
    int size;
    int tail;
    void **buf;
} vector_t;

typedef struct queue_cycl_s {
    int front;
    int tail;
    int max_size;
    void **cyclic_buf;
} queue_cycl_t;

vector_t *vector_init(int size) {
    vector_t *tmp = (vector_t *)calloc(1, sizeof(vector_t));
    if (tmp == NULL) {
        fprintf(stderr, ""vector_init error\\n"");
        exit(1);
    }

    tmp->buf = (void **)calloc(size, sizeof(void *));
    if (tmp->buf == NULL) {
        fprintf(stderr, ""vector_init error\\n"");
        free(tmp);
        exit(1);
    }

    tmp->size = size;
    tmp->tail = 0;

    return tmp;
}

int vector_push_back(vector_t *v, void *data) {
    if (v->tail == v->size)
        return 0;

    v->buf[v->tail++] = data;

    return 1;
}

void *vector_pop_back(vector_t *v) {
    return (v->tail == 0) ? NULL : v->buf[--(v->tail)];
}

void vector_delete(vector_t *v) {
    free(v->buf);
    free(v);
}

queue_cycl_t *queue_init() {
    queue_cycl_t *tmp = (queue_cycl_t *)calloc(1, sizeof(queue_cycl_t));
    if (tmp == NULL) {
        fprintf(stderr, ""queue_init error\\n"");
        exit(1);
    }

    tmp->max_size = QUEUE_BUF_SIZE + 1;
    tmp->cyclic_buf = (void **)calloc(tmp->max_size, sizeof(void *));
    if (tmp->cyclic_buf == NULL) {
        fprintf(stderr, ""queue_init error\\n"");
        free(tmp);
        exit(1);
    }

    return tmp;
}

int queue_size(queue_cycl_t *q) {
    return (q->tail >= q->front) ? (q->tail - q->front) : (q->max_size - q->front + q->tail);
}

int queue_is_full(queue_cycl_t *q) {
    return ((q->tail + 1) % q->max_size == q->front);
}

int queue_is_empty(queue_cycl_t *q) {
    return (q->front == q->tail);
}

int queue_enqueue(queue_cycl_t *q, void *data) {
    if (queue_is_full(q))
        return 0;

    q->cyclic_buf[q->tail] = data;
    q->tail = (q->tail + 1) % q->max_size;

    return 1;
}

void *queue_dequeue(queue_cycl_t *q) {
    if (queue_is_empty(q))
        return NULL;
    void *tmp = q->cyclic_buf[q->front];
    q->cyclic_buf[q->front] = NULL;
    q->front = (q->front + 1) % q->max_size;

    return tmp;
}

vector_t *queue_dequeueall(queue_cycl_t *q) {
    int s = queue_size(q);
    vector_t *tmp = vector_init(s);
    void *data = NULL;

    while ((data = queue_dequeue(q)) != NULL) {
        if (!vector_push_back(tmp, data)) {
            queue_enqueue(q, data);
            fprintf(stderr, ""queue_dequeueall error\\n"");
            exit(1);
        }
    }

    return tmp;
}

void queue_delete(queue_cycl_t *q) {
    free(q->cyclic_buf);
    free(q);
}

typedef struct actor_s {
    pthread_t thread;
    pthread_mutex_t m;
    pthread_cond_t cond;
    queue_cycl_t *q;
} actor_t;

void actor_send_to(actor_t *a, void *msg) {
    pthread_mutex_lock(&a->m);
    queue_enqueue(a->q, msg);
    pthread_cond_signal(&a->cond);
    pthread_mutex_unlock(&a->m);
}

void *actor_runner(void *arg) {
    actor_t *iam = (actor_t *)arg;
    int buf[50] = {0};

    while (1) {
        pthread_mutex_lock(&iam->m);
        while (queue_is_empty(iam->q)) {
            pthread_cond_wait(&iam->cond, &iam->m);
        }
        vector_t *v = queue_dequeueall(iam->q);
        pthread_mutex_unlock(&iam->m);

        int *data = NULL, exit_flag = 0;
        while ((data = vector_pop_back(v)) != NULL) {
            if (*data == -1) {
                exit_flag = 1;
            } else {
                buf[*data]++;
            }
            free(data);
        }
        vector_delete(v);
        if (exit_flag) break;
    }

    for (int i = 0; i < 50; i++) {
        if (buf[i] != n_senders) {
            fprintf(stderr, ""ERROR!!!!!!!!\\n"");
        }
    }

    return NULL;
}

actor_t *actor_init() {
    actor_t *tmp = (actor_t *)calloc(1, sizeof(actor_t));
    if (tmp == NULL) {
        fprintf(stderr, ""actor_init error\\n"");
        exit(1);
    }

    pthread_mutex_init(&tmp->m, NULL);
    pthread_cond_init(&tmp->cond, NULL);
    tmp->q = queue_init();
    pthread_create(&tmp->thread, NULL, actor_runner, tmp);

    return tmp;
}

void actor_finalize(actor_t *a) {
    pthread_join(a->thread, NULL);
    queue_delete(a->q);
    pthread_mutex_destroy(&a->m);
    pthread_cond_destroy(&a->cond);
    free(a);
}

void *sender(void *arg) {
    actor_t *receiver = (actor_t *)arg;
    int *msg = NULL;

    for (int i = 0; i < 50; i++) {
        msg = (int *)calloc(1, sizeof(int));
        if (msg == NULL) {
            fprintf(stderr, ""Memory allocation failed\\n"");
            exit(1);
        }
        *msg = i;
        actor_send_to(receiver, msg);
    }

    return NULL;
}

int main(int argc, char **argv) {
    if (argc != 2) {
        fprintf(stderr, ""Usage: %s <number_of_senders>\\n"", argv[0]);
        exit(1);
    }

    n_senders = atoi(argv[1]);
    pthread_t *senders_id = (pthread_t *)calloc(n_senders, sizeof(pthread_t));
    if (senders_id == NULL) {
        fprintf(stderr, ""Memory allocation failed\\n"");
        exit(1);
    }

    actor_t *actor = actor_init();
    for (int i = 0; i < n_senders; i++) {
        pthread_create(&senders_id[i], NULL, sender, actor);
    }

    for (int i = 0; i < n_senders; i++) {
        pthread_join(senders_id[i], NULL);
    }

    int *msg_ext = (int *)calloc(1, sizeof(int));
    *msg_ext = -1;
    actor_send_to(actor, msg_ext);
    actor_finalize(actor);

    free(senders_id);
    return 0;
}

",0
"#include <stdio.h>
#include <pthread.h>
#include <assert.h>

static volatile int counter = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *entry_point(void *arg) {
    printf(""Thread %s: begin\\n"", (char *)arg);
    
    for (int i = 0; i < 1e7; ++i) {
        counter += 1;
    }
    
    printf(""Thread %s: done\\n"", (char *)arg);
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t p1, p2;
    printf(""main: begin with counter = %d\\n"", counter);
    int rc;
    rc = pthread_create(&p1, NULL, entry_point, (void *)""A"");
    assert(rc == 0);
    rc = pthread_create(&p2, NULL, entry_point, (void *)""B"");
    assert(rc == 0);

    // join waits for the threads to finish
    rc = pthread_join(p1, NULL);
    assert(rc == 0);
    rc = pthread_join(p2, NULL);
    assert(rc == 0);
    printf(""main: done with counter = %d\\n"", counter);
    return 0;
}
",1
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include <stdbool.h>


struct mode_extra_status
{
  int output_pipe_fd;
  pthread_mutex_t mutex;
  union switch_data answer;
  long long rest_time[SWITCH_BUTTON_NUM + 1];
  int score;
  pthread_t background_worker;
  bool terminated;
};

static void *background_worker_main (void *arg);

struct mode_extra_status *mode_extra_construct (int output_pipe_fd)
{
  struct mode_extra_status *status;
  status = malloc (sizeof (*status));

  status->output_pipe_fd = output_pipe_fd;
  pthread_mutex_init (&status->mutex, 0);
  status->answer.val = 0;
  status->score = 0;
  status->terminated = 0;

  pthread_create (&status->background_worker, 0, &background_worker_main, status);

  return status;
}

void mode_extra_destroy (struct mode_extra_status *status)
{
  atomic_store_bool (&status->terminated, 1);
  pthread_join (status->background_worker, 0);
  pthread_mutex_destroy (&status->mutex);
  free (status);
}

int mode_extra_switch (struct mode_extra_status *status, union switch_data data)
{
  pthread_mutex_lock (&status->mutex);

  int16_t correct = status->answer.val & data.val;
  int16_t incorrect = (status->answer.val ^ data.val) & data.val;

  LOG (LOGGING_LEVEL_HIGH, ""[Main Process] correct = %03X, incorrect = %03X."", correct, incorrect);

  status->answer.val ^= correct;

  for (int i = 0; i < SWITCH_BUTTON_NUM; ++i)
    {
      status->score += (correct & 1);
      status->score -= (incorrect & 1);
      correct >>= 1;
      incorrect >>= 1;
    }
  if (status->score < 0)
    status->score = 0;

  output_message_fnd_send (status->output_pipe_fd, status->score);

  pthread_mutex_unlock (&status->mutex);

  return 0;
}

static void *background_worker_main (void *arg)
{
  struct mode_extra_status *status = arg;

  long long prev_nano_time = get_nano_time ();
  long long prev_creation_time = 0;

  while (!atomic_load_bool (&status->terminated))
    {
      pthread_mutex_lock (&status->mutex);

      long long cur_nano_time = get_nano_time ();
      long long time_gap = cur_nano_time - prev_nano_time;
      prev_nano_time = cur_nano_time;
# 110 ""mode_extra.c""
      if (status->answer.bit_fields.s1) { status->rest_time[ 1 ] -= time_gap; if (status->rest_time[ 1 ] < 0) { status->answer.bit_fields.s1 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s2) { status->rest_time[ 2 ] -= time_gap; if (status->rest_time[ 2 ] < 0) { status->answer.bit_fields.s2 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s3) { status->rest_time[ 3 ] -= time_gap; if (status->rest_time[ 3 ] < 0) { status->answer.bit_fields.s3 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s4) { status->rest_time[ 4 ] -= time_gap; if (status->rest_time[ 4 ] < 0) { status->answer.bit_fields.s4 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s5) { status->rest_time[ 5 ] -= time_gap; if (status->rest_time[ 5 ] < 0) { status->answer.bit_fields.s5 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s6) { status->rest_time[ 6 ] -= time_gap; if (status->rest_time[ 6 ] < 0) { status->answer.bit_fields.s6 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s7) { status->rest_time[ 7 ] -= time_gap; if (status->rest_time[ 7 ] < 0) { status->answer.bit_fields.s7 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s8) { status->rest_time[ 8 ] -= time_gap; if (status->rest_time[ 8 ] < 0) { status->answer.bit_fields.s8 = 0; if (status->score > 0) --status->score; } };
      if (status->answer.bit_fields.s9) { status->rest_time[ 9 ] -= time_gap; if (status->rest_time[ 9 ] < 0) { status->answer.bit_fields.s9 = 0; if (status->score > 0) --status->score; } };



      long long delay_base = 300LL * 1000LL * 1000LL;
      long long micro_delay = (rand () % 10 + 1) * delay_base;
      double delay_coef = 5 / ((status->score + 10) / 20.0);

      if (cur_nano_time - prev_creation_time > delay_coef * delay_base)
        {
          int no = 1 + rand () % SWITCH_BUTTON_NUM;
          status->rest_time[no] = micro_delay;
          status->answer.val |= (1 << (no-1));
          prev_creation_time = cur_nano_time;
        }

      output_message_fnd_send (status->output_pipe_fd, status->score);

      struct dot_matrix_data dot_data = { { { 0, }, } };
      int16_t bit_mask = 1;
      const int x_jump = 2, x_size = 3;
      const int y_jump = 3, y_size = 4;
      for (int i = 0; i < 3; ++i)
        {
          for (int j = 0; j < 3; ++j)
            {
              if (status->answer.val & bit_mask)
                {
                  int base_y = i * y_jump;
                  int base_x = j * x_jump;
                  for (int y = base_y; y < base_y + y_size; ++y)
                    for (int x = base_x; x < base_x + x_size; ++x)
                      dot_data.data[y][x] = 1;
                }
              bit_mask <<= 1;
            }
        }
      output_message_dot_matrix_send (status->output_pipe_fd, &dot_data);

      pthread_mutex_unlock (&status->mutex);

      usleep ((10*1000));
    }

  return 0;
}
",0
"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <assert.h>
#include <sys/time.h>

#define NUM_BUCKETS 5     // Buckets in hash table
#define NUM_KEYS 100000   // Number of keys inserted per thread
int num_threads = 1;      // Number of threads (configurable)
int keys[NUM_KEYS];
pthread_mutex_t lock[NUM_BUCKETS]; // declare lock (mutex)

typedef struct _bucket_entry {
    int key;
    int val;
    struct _bucket_entry *next;
} bucket_entry;

bucket_entry *table[NUM_BUCKETS];

void panic(char *msg) {
    printf(""%s\\n"", msg);
    exit(1);
}

double now() {
    struct timeval tv;
    gettimeofday(&tv, 0);
    return tv.tv_sec + tv.tv_usec / 1000000.0;
}

// Inserts a key-value pair into the table
void insert(int key, int val) {
    int i = key % NUM_BUCKETS;
 
    bucket_entry *e = (bucket_entry *) malloc(sizeof(bucket_entry));
    if (!e) panic(""No memory to allocate bucket!"");
    pthread_mutex_lock(&lock[i]);
    e->next = table[i];
    e->key = key;
    e->val = val;
    table[i] = e;
    // Obtain the stack of unlock (mutex)
    pthread_mutex_unlock(&lock[i]);
}

// Retrieves an entry from the hash table by key
// Returns NULL if the key isn't found in the table
bucket_entry * retrieve(int key) {
    bucket_entry *b;
    for (b = table[key % NUM_BUCKETS]; b != NULL; b = b->next) {
        if (b->key == key) return b;
    }
    return NULL;
}

void * put_phase(void *arg) {
    long tid = (long) arg;
    int key = 0;

    // If there are k threads, thread i inserts
    //      (i, i), (i+k, i), (i+k*2)
    for (key = tid ; key < NUM_KEYS; key += num_threads) {
        insert(keys[key], tid); // added check for [key] to be added or not
    }

    pthread_exit(NULL);
}

void * get_phase(void *arg) {
    long tid = (long) arg;
    int key = 0;
    long lost = 0;

    for (key = tid ; key < NUM_KEYS; key += num_threads) {
        if (retrieve(keys[key]) == NULL) lost++; // added check for [key] to be added or not
    }
    printf(""[thread %ld] %ld keys lost!\\n"", tid, lost);

    pthread_exit((void *)lost);
}

int main(int argc, char **argv) {
    long i;
    pthread_t *threads;
    double start, end;

    if (argc != 2) {
        panic(""usage: ./parallel_hashtable <num_threads>"");
    }
    if ((num_threads = atoi(argv[1])) <= 0) {
        panic(""must enter a valid number of threads to run"");
    }

    srandom(time(NULL));
    for (i = 0; i < NUM_KEYS; i++)
        keys[i] = random();

    // initialize the lock
    for (i = 0; i < NUM_BUCKETS; i ++)
        pthread_mutex_init(&lock[i], NULL);
    threads = (pthread_t *) malloc(sizeof(pthread_t)*num_threads);
    if (!threads) {
        panic(""out of memory allocating thread handles"");
    }

    // Insert keys in parallel
    start = now();
    for (i = 0; i < num_threads; i++) {
        pthread_create(&threads[i], NULL, put_phase, (void *)i);
    }
    
    // Barrier
    for (i = 0; i < num_threads; i++) {
        pthread_join(threads[i], NULL);
    }
    end = now();
    
    printf(""[main] Inserted %d keys in %f seconds\\n"", NUM_KEYS, end - start);
    
    // Reset the thread array
    memset(threads, 0, sizeof(pthread_t)*num_threads);

    // Retrieve keys in parallel
    start = now();
    for (i = 0; i < num_threads; i++) {
        pthread_create(&threads[i], NULL, get_phase, (void *)i);
    }

    // Collect count of lost keys
    long total_lost = 0;
    long *lost_keys = (long *) malloc(sizeof(long) * num_threads);
    for (i = 0; i < num_threads; i++) {
        pthread_join(threads[i], (void **)&lost_keys[i]);
        total_lost += lost_keys[i];
    }
    end = now();

    printf(""[main] Retrieved %ld/%d keys in %f seconds\\n"", NUM_KEYS - total_lost, NUM_KEYS, end - start);

    return 0;
}


",1
"#include <pthread.h>
#include <iostream>
#include <unistd.h>
using namespace std;

#define NUM_THREADS  3
#define TCOUNT 10
#define COUNT_LIMIT 12

int count1 = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

void *inc_count(void *t) {
    long my_id = (long)t;

    for (int i = 0; i < TCOUNT; i++) {
        pthread_mutex_lock(&count_mutex);
        count1++;

        if (count1 >= COUNT_LIMIT) {
            cout << ""inc_count(): thread "" << my_id << "", count = "" << count1 << ""  Threshold reached. "";
            pthread_cond_broadcast(&count_threshold_cv); // Changed to broadcast
            cout << ""Just sent signal.\\n"";
        }
        cout << ""inc_count(): thread "" << my_id << "", count = "" << count1 << "", unlocking mutex\\n"";
        pthread_mutex_unlock(&count_mutex);
        usleep(100); // Not ideal, but kept as is per the original code
    }
    pthread_exit(NULL);
}

void *watch_count(void *t) {
    long my_id = (long)t;

    cout << ""Starting watch_count(): thread "" << my_id << ""\\n"";
    pthread_mutex_lock(&count_mutex);
    while (count1 < COUNT_LIMIT) {
        cout << ""watch_count(): thread "" << my_id << "" Count= "" << count1 << "". Going into wait...\\n"";
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        cout << ""watch_count(): thread "" << my_id << "" Condition signal received. Count= "" << count1 << ""\\n"";
    }

    // Update the count as per original logic
    cout << ""watch_count(): thread "" << my_id << "" Updating the value of count...\\n"";
    count1 += 125;
    cout << ""watch_count(): thread "" << my_id << "" count now = "" << count1 << "".\\n"";
    
    cout << ""watch_count(): thread "" << my_id << "" Unlocking mutex.\\n"";
    pthread_mutex_unlock(&count_mutex);
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
    long t1 = 1, t2 = 2, t3 = 3;
    pthread_t threads[3];
    pthread_attr_t attr;

    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init(&count_threshold_cv, NULL);

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
    pthread_create(&threads[2], &attr, inc_count, (void *)t3);

    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    cout << ""Main(): Waited and joined with "" << NUM_THREADS << "" threads. Final value of count = "" << count1 << "". Done.\\n"";

    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    pthread_exit(NULL);
}

",0
"#include <pthread.h>
#include <iostream>
#include <cstdlib>
using namespace std;

#define THREADNUM 4
#define VECLEN 1000000

struct DOT {
    int *a;
    int *b;
    long long int sum;
    long int veclen;
};

DOT data;
pthread_t callThd[THREADNUM];
pthread_mutex_t mutexsum;

void *dotprod(void *arg)
{
    long offset = reinterpret_cast<long>(arg);
    int start, end, len;
    long long int threadsum = 0;
    int *x, *y;
    
    len = data.veclen;
    start = offset * len;
    end = start + len;
    x = data.a;
    y = data.b;

    // Common code for each thread, operates based on the thread number (= offset)
    for (int i = start; i < end; i++) {
        threadsum += static_cast<long long int>(x[i]) * y[i];
    }

    // Occupy mutex lock because we are changing the value of shared sum
    
    data.sum += threadsum;
    cout << ""Thread "" << offset << "" did "" << start << "" to "" << end
         << "":  ThreadSum = "" << threadsum << "", global sum = "" << data.sum << ""\\n"";
    

    pthread_exit(nullptr);
}

int main(int argc, char *argv[])
{
    int i;
    int *a, *b;
    void *status;
    pthread_attr_t attr;

    // Intilizing all the values
    a = (int*) malloc(THREADNUM * VECLEN * sizeof(int));
    b = (int*) malloc(THREADNUM * VECLEN * sizeof(int));

    if (a == nullptr || b == nullptr) {
        cerr << ""Error allocating memory for vectors.\\n"";
        exit(1);
    }

    for (i = 0; i < VECLEN * THREADNUM; i++) {
        a[i] = rand() % 100;  // Change this to generate values in an appropriate range
        b[i] = rand() % 100;  // Change this to generate values in an appropriate range
    }

    data.veclen = VECLEN;
    data.a = a;
    data.b = b;
    data.sum = 0;

    pthread_mutex_init(&mutexsum, nullptr);
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    for (i = 0; i < THREADNUM; i++) {
        pthread_create(&callThd[i], &attr, dotprod, reinterpret_cast<void*>(i));
    }

    pthread_attr_destroy(&attr);

    // Wait for all threads to complete
    for (i = 0; i < THREADNUM; i++) {
        pthread_join(callThd[i], &status);
    }

    cout << ""Sum = "" << data.sum << "" \\n"";

    free(a);
    free(b);
    pthread_mutex_destroy(&mutexsum);
    pthread_exit(nullptr);
}

",1
"#include ""helper.h""

/*
 * Helper routines for pthreads
 */

void pclock(char *msg, clockid_t cid) {
    struct timespec ts;
    printf(""%s"", msg);
    if (clock_gettime(cid, &ts) == -1) {
        perror(""clock_gettime"");
        return;
    }
    printf(""%4ld.%03ld\\n"", ts.tv_sec, ts.tv_nsec / 1000000);
}

void errp(char *s, int code) {
    fprintf(stderr, ""Error: %s -- %s\\n"", s, strerror(code));
}

void thr_sleep(time_t sec, long nsec) {
    struct timeval now;
    struct timezone tz;
    struct timespec ts;
    int retcode;

    pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

    retcode = pthread_mutex_lock(&m);
    if(retcode) {
        fprintf(stderr, ""Error: mutex_lock -- %s\\n"", strerror(retcode));
        return;
    }

    gettimeofday(&now, &tz);
    ts.tv_sec = now.tv_sec + sec + (nsec / 1000000000L);
    ts.tv_nsec = (now.tv_usec * 1000) + (nsec % 1000000000L);
    if(ts.tv_nsec > 1000000000L) {
        (ts.tv_sec)++;
        (ts.tv_nsec) -= 1000000000L;
    }

    retcode = pthread_cond_timedwait(&cond, &m, &ts);
    if(retcode != ETIMEDOUT) {
        if(retcode == 0) {
            fprintf(stderr, ""pthread_cond_timedwait returned early.\\n"");
        } else {
            fprintf(stderr, ""pthread_cond_timedwait error: %s\\n"", strerror(retcode));
            return;
        }
    }

    retcode = pthread_mutex_unlock(&m);
    if(retcode) {
        fprintf(stderr, ""Error: mutex_unlock -- %s\\n"", strerror(retcode));
        return;
    }

    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&m);
}

void mulock(int ul, pthread_mutex_t *m) {
    int retcode = 0;
    char myErrStr[100];

    if (ul) {
        strcpy(myErrStr, ""mutex_unlock"");
        retcode = pthread_mutex_unlock(m);
    } else {
        strcpy(myErrStr, ""mutex_lock"");
        retcode = pthread_mutex_lock(m);
    }
    
    if (retcode) {
        fprintf(stderr, ""%s, %s\\n"", myErrStr, strerror(retcode));
    }
}

",0