Multithreading Problems

Author: vinayak-sethi

Lab6/COE18B061.pdf

@@ -0,0 +1,108 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#include<pthread.h>
+
+#define MAX 1000
+
+struct length
+{
+    int len1;
+    int len2;
+};
+
+char s1[MAX], s2[MAX];
+
+void *LCS(void *arg);
+int max(int a, int b);
+
+int main()
+{
+    printf("\nEnter the string 1: ");
+    scanf("%s", s1);
+
+    printf("\nEnter the string 2: ");
+    scanf("%s", s2);
+
+    struct length *param = (struct length *)malloc(sizeof(struct length));
+
+    param->len1 = strlen(s1);  //length of string 1
+    param->len2 = strlen(s2);  //length of string 2
+
+    pthread_t tid; //returns the thread id of thread created
+    pthread_attr_t attr; //to define thread attributes
+	pthread_attr_init(&attr); //initializes the thread attributes
+
+    pthread_create(&tid, &attr, LCS, param); //creates a new thread
+    
+    int *max_len; //define the value from thread
+
+    pthread_join(tid, (void *)&max_len); //wait for termination of the thread
+
+    printf("\nLength of LCS: %d\n\n", *max_len);
+
+    return 0;
+}
+
+void *LCS(void *arg)
+{
+    int len1 = ((struct length *)arg)->len1;
+    int len2 = ((struct length *)arg)->len2;
+
+    // Define return variable
+	int *ret = malloc(sizeof(int));
+	*ret = 0;
+
+    if(len1 == 0 || len2 == 0)
+        pthread_exit(ret); //to exit a thread
+
+    if(s1[len1-1] == s2[len2-1])
+    {
+        // Define a new struct copied from the arg
+		struct length arg_1 = *((struct length *)arg);
+		--arg_1.len1;
+		--arg_1.len2;
+
+		// Recursively call the thread again
+		pthread_t tid; //returns the thread id of thread created
+        pthread_attr_t attr; //to define thread attributes
+	    pthread_attr_init(&attr); //initializes the thread attributes
+		pthread_create(&tid,&attr,LCS,(void *)&arg_1); //creates a new thread
+
+		// Get return value from thread
+		int *ret_1;
+		pthread_join(tid,(void*)&ret_1);
+		*ret = *ret_1 + 1;
+	}
+	else
+	{
+		// Define new structs copied from the arg
+		struct length arg_1 = *((struct length*)arg);
+		--arg_1.len2;
+
+		struct length arg_2 = *((struct length*)arg);
+		--arg_2.len1;
+
+		// Recursively call the thread again
+		pthread_t tid[2]; //returns the thread id of thread created
+        pthread_attr_t attr; //to define thread attributes
+	    pthread_attr_init(&attr); //initializes the thread attributes
+		pthread_create(&tid[0],NULL,LCS,(void *)&arg_1);
+		pthread_create(&tid[1],NULL,LCS,(void *)&arg_2);
+
+		// Get return value from both threads
+		int *ret_1, *ret_2;
+		pthread_join(tid[0],(void*)&ret_1);
+		pthread_join(tid[1],(void*)&ret_2);
+
+		*ret = max(*ret_1,*ret_2);
+	}
+	pthread_exit(ret); //to exit a thread
+}
+
+int max(int a, int b)
+{
+	if(a > b)
+		return a;
+	return b;
+}

Lab6/Q10_LongestCommonSubsequence

@@ -0,0 +1,72 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<pthread.h>
+#include<math.h>
+
+#define MAX 10000
+
+int start, end;
+int store_sum[MAX];
+
+void *runner(void *num);
+
+int main(int argc, char *argv[])
+{
+	//Validate the usage of command line arguments
+    if(argc < 3)
+    {
+        printf("\nSyntax: %s <Starting Number> <Ending Number>\n\n", argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    start = atoi(argv[1]);
+    end = atoi(argv[2]);
+
+	printf("\nSet of Armstrong numbers between %d and %d are { ", start, end);
+
+	for(int i=start; i<=end; i++)
+    {
+        int *val = (int *)malloc(sizeof(int));
+        *val = i;
+
+        pthread_t tid; //returns the thread id of thread created
+        pthread_attr_t attr; //to define thread attributes
+        pthread_attr_init(&attr); //initializes the thread attributes
+
+        pthread_create(&tid, &attr, runner, val); //creates a new thread
+        pthread_join(tid, NULL); //wait for termination of the thread
+    }
+
+    for(int i=0; i<=end-start; i++)
+        if(store_sum[i] == i+start)
+            printf("%d ", store_sum[i]);
+        
+	printf("\b }\n\n");
+    return 0;
+}
+
+void *runner(void *num)
+{
+	int *val = (int *)num;
+	int temp = *val;
+	int i = 0;
+	int sum = 0;
+
+	while(temp != 0)
+	{
+	 	i++; // counts the number of digit in the number
+		temp = temp/10;
+	}
+
+	temp = *val;	
+	while(temp != 0)
+	{
+		sum = sum + pow(temp%10, i); 
+		temp = temp/10;
+	}
+
+	store_sum[*val - start] = sum; //stores the value of sum
+
+    pthread_exit(0); //to exit a thread
+}
+

Lab6/Q10_LongestCommonSubsequence.c

@@ -0,0 +1,110 @@
+#include<stdio.h>
+#include<stdlib.h>
+#include<stdbool.h>
+#include<pthread.h>
+
+struct array
+{
+	int a[100];
+	int size;
+};
+
+void *runner1(void *arg); //for ascending order sort
+void *runner2(void *arg); //for descending order sort
+void bubblesort(int *arr, int n, bool(*oprn)(const void *,const void *)); //using function pointer
+bool asc(const void *a, const void *b);
+bool desc(const void *a, const void *b);
+void swap(int *a,int *b);
+void print(int *arr,int n);
+
+int main(int argc, char *argv[])
+{
+	//Validate correct number of arguments
+	if(argc < 2)
+	{
+		printf("\nWrong usage.. Syntax: %s <Array elements> \n\n", argv[0]);
+		exit(EXIT_FAILURE);
+	}
+
+	struct array *arr = (struct array *)malloc(sizeof(struct array));
+	arr->size = argc - 1;
+
+	printf("\nThe size of Array : %d", arr->size);
+	printf("\nThe Elements of the Array : ");
+	for(int i=1; i<argc; i++)
+	{
+		arr->a[i-1] = atoi(argv[i]);
+	}
+	print(arr->a, arr->size);
+
+	pthread_t tid1, tid2; //returns the thread id of thread created
+    pthread_attr_t attr; //to define thread attributes
+    pthread_attr_init(&attr); //initializes the thread attributes
+
+    pthread_create(&tid1, &attr, runner1, arr); //creates a new thread for ascending sort
+	pthread_create(&tid2, &attr, runner2, arr); //creates a new thread for descending sort
+    
+	pthread_join(tid1, NULL); //wait for termination of the thread1
+	pthread_join(tid2, NULL); //wait for termination of the thread2
+
+	printf("\n");
+	return 0;
+}
+
+void *runner1(void *arg)
+{
+	struct array *arr = (struct array *)arg;
+	printf("\nArray Sorted in Ascending order : ");
+	bubblesort(arr->a, arr->size,asc);
+	print(arr->a, arr->size);
+
+	pthread_exit(0); //to exit a thread
+}
+
+void *runner2(void *arg)
+{
+	struct array *arr = (struct array *)arg;
+	printf("Array Sorted in Descending order : ");
+	bubblesort(arr->a, arr->size, desc);
+	print(arr->a, arr->size);
+
+	pthread_exit(0); //to exit a thread
+}
+
+void bubblesort(int *arr,int n, bool(*oprn)(const void *,const void *))
+{
+	for(int i=0; i<n-1; i++)
+	{
+		for(int j=0; j<n-i-1; j++)
+		{
+			if(oprn(&arr[j],&arr[j+1]))
+				swap(&arr[j],&arr[j+1]);
+		}
+	}
+}
+
+bool asc(const void *a, const void *b)
+{
+	return *(int *)a > *(int *)b;
+}
+
+bool desc(const void *a, const void *b)
+{
+	return *(int *)a < *(int *)b;
+}
+
+void swap(int *a,int *b)
+{
+	int c = *a;
+	*a = *b;
+	*b = c;
+}
+
+void print(int *arr,int n)
+{
+	for(int i=0; i<n; i++)
+	{
+		printf("%d ",arr[i]);
+	}
+	printf("\n");
+}