Pushing labs 1->6

All laboratories of the first part of the course, related to Linux
(system and device) programming

Author: dgallitelli

Lab1/D01/E01.c

@@ -0,0 +1,99 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <fcntl.h>
+
+int cmpfunc (const void*, const void*);
+
+int main(int argc, char* argv[]){
+	if (argc != 3){
+		fprintf(stderr, "Error: wrong # of arguments");
+		return -1;
+	}
+	
+	srand(time(NULL));
+	// Take from command line two integer numbers - as parameters
+	int n1 = atoi(argv[1]);
+	int n2 = atoi(argv[2]);
+	
+	// Allocate two vectors v1 and v2
+	int *v1 = malloc(n1*sizeof(int));
+	int *v2 = malloc(n2*sizeof(int));
+
+	// Fill v1 with n1 random numbers between 10 and 100 - need random lib
+	for (int i=0; i<n1; i++){
+		do {
+			v1[i] = rand() % 90;
+			v1[i] += 10;
+		} while (v1[i]%2!=0);
+	}
+	// Fill v2 with n2 random numbers between 21 and 101 - need random lib
+	for (int i=0; i<n2; i++){
+		do {
+			v2[i] = rand() % 81;
+			v2[i] += 21;
+		} while (v2[i]%2==0);
+	}
+	// Printing arrays before Sorting
+	printf("Array before sort:\n");
+	printf("Array 1:\n");
+	for (int i=0; i<n1; i++) printf ("%d\t", v1[i]);
+	printf("\n");
+	printf("Array 2:\n");
+	for (int i=0; i<n2; i++) printf ("%d\t", v2[i]);
+	printf("\n");
+
+	//Sort v1 and v2
+	qsort(v1, n1, sizeof(int), cmpfunc);
+	qsort(v2, n2, sizeof(int), cmpfunc);
+
+	// Print after sort (to check)
+	printf("Array after sort:\n");
+	printf("Array 1:\n");
+	for (int i=0; i<n1; i++) printf ("%d\t", v1[i]);
+	printf("\n");
+	printf("Array 2:\n");
+	for (int i=0; i<n2; i++) printf ("%d\t", v2[i]);
+	printf("\n");
+
+	// Print the first text file
+	int fv1, fv2;
+	if ((fv1 = open("fv1.txt", O_WRONLY | O_CREAT, 0777))<0){
+		return -1;
+	}
+	char myBuff1[n1*4 + 4];
+	int j = 0;
+	for (int i=0; i<n1; i++) j+=sprintf(&myBuff1[j], "%d ", v1[i]);
+	write(fv1, myBuff1, sizeof(char)*j);
+	close(fv1);
+	printf("File v1 written. \n");
+
+	// Print the second text file
+	if ((fv2 = open("fv2.txt", O_WRONLY | O_CREAT, 0777))<0){
+		return -1;
+	}
+	char myBuff2[n2*4 + 4];
+	j = 0;
+	for (int i=0; i<n2; i++) j+=sprintf(&myBuff2[j], "%d ", v2[i]);
+	write(fv2, myBuff2, sizeof(char)*j);
+	close(fv2);
+	printf("File v2 written. \n");
+
+	// Print v1 in fv1.b
+	if ((fv1 = open("fv1.b", O_WRONLY | O_CREAT, 0777))<0){
+		return -1;
+	}
+	write(fv1, v1, sizeof(int)*n1);
+	// Print v2 in fv2.b
+	if ((fv2 = open("fv2.b", O_WRONLY | O_CREAT, 0777))<0){
+		return -1;
+	}
+	write(fv2, v2, sizeof(int)*n2);
+
+	exit(1);
+}
+
+int cmpfunc (const void * a, const void * b){
+	return ( *(int*)a - *(int*)b );
+}

Lab1/D01/E01_report.md

@@ -0,0 +1,35 @@
+# SDP 2016/17 - Lab 1 - Davide Gallitelli S241521
+
+### E01 - C program for file generation
+The first task of this laboratory asks to implement a C program which creates a total of four files, fv1 and fv2 as both binary and text files, containing a user-specified number of random integer numbers.
+
+In order to receive from input these values, the approach chosen is to read them from command line as arguments of the program. This means that _argv[1]_ and _argv[2]_ will have the characters related to the values in input. The _atoi_ function is used to return the integer value from the ASCII read by the console. If the number of arguments is different from 3 (./file n1 n2), the program prints an error and exits with a -1 return value.
+
+```
+    if (argc != 3){
+		fprintf(stderr, "Error: wrong # of arguments");
+		return -1;
+	}
+	
+	srand(time(NULL));
+	// Take from command line two integer numbers - as parameters
+	int n1 = atoi(argv[1]);
+	int n2 = atoi(argv[2]);
+```
+
+In order to allocate an array with a dimension defined by a variable, a dynamic array has to be allocated by means of the _malloc_ function:
+
+```
+	int *v1 = malloc(n1*sizeof(int));
+	int *v2 = malloc(n2*sizeof(int));
+```
+
+According to the given specification, the values accepted for the array elements are:
+
+- file v1: even integers between 10 and 100 --> generate even integers from 0 to 90 then add 10
+- file v2: odd integers between 21 and 101 --> generate odd integers from 0 to 80 then add 21
+To sort the arrays just generated, the _qsort_ function of the C _stdlib_. 
+
+The _open()_ system call allows to both open and create, with specified permissions, files, returning an integer associated to the file descriptor. Our goal is to print to a text file the characters which relate to the integer from the array. To achieve this, we iterate over the array, pushing the values to a string by means of the _sprintf()_ call. This calls return the actual number of chars written, which is why it is used through the _j_ variable to determine the size of the buffer for the later _write()_ call. The _write()_ call finalizes the writing of the buffer into the text file, having as parameter the file descriptor, the buffer itself (the string previously generated with the _sprintf()_) and the size of the string, which is _j_ times the size of a character in bytes. This value will never exceed _n1*4 + 4_ (or _n2*4 + 4_), because the worst case possible is having n1 (or n2) times the value "100", which needs 3 characters as well as one character for a space to separate the values. The last 4 characters are added for CR.
+
+In order to write a binary file, it is sufficient to call a _write()_ function on the binary file, writing the generating array (v1 or v2), which will have size of n1 (or n2) times the size of an integer.

Lab1/D01/E01_report.pdf

@@ -0,0 +1,37 @@
+## E01 - C program for file generation
+
+Implement a C program that:
+
+-   takes from the command line two integer numbers n1, n2,
+-   allocates two vectors v1 and v2, of dimensions n1 and n2, respectively,
+-   fills v1 with n1 random even integer numbers between 10-100,
+-   fills v2 with n2 random odd integer numbers between 21-101,
+-   sort v1 and v2 (increasing values),
+-   save the content of vectors v1 and v2 in two text files fv1.txt and
+fv2.txt, respectively,
+-   save the content of vectors v1 and v2 in two binary files fv1.b and
+fv2.b, respectively,
+Use command _od_ for verifying the content of files v1, v2.
+
+_Standard ANSI C_
+```
+FILE *fpw; // file pointer
+if ((fpw = fopen (filename, "wb")) == NULL){ // w for write,
+b for binary
+fprinf(stderr," error open %s\n", filename);
+return(1);
+}
+fwrite(buffer,sizeof(buffer),1, fpw); // write sizeof(buffer)
+bytes from buffer
+```
+_Using Unix system calls_
+```
+#include <unistd.h>
+#include <fcntl.h>
+int fdo; // file descriptor
+if ((fdo = open(filename, O_WRONLY)) < 0){
+fprinf(stderr," error open %s\n", filename);
+return 1;
+}
+write(fdo, buffer, sizeof(buffer));
+```

Lab1/D01/E01_text.md

@@ -0,0 +1,16 @@
+## E02 - Synchronization with semaphores
+
+Implement a concurrent program in C language, using Pthreads, which creates two client
+threads, then it acts as a server.
+
+A client thread loops reading the next number from the binary file (fv1.b and fv2.b,
+respectively), and storing it in a global variable g. Then, it performs a signals on a
+semaphore to indicate to the server that the variable is ready, and it waits on a semaphore
+a signal from the server indicating that the number has been processed (simply multiplied
+by 3), finally, it prints the result and its identifier.
+The server loops waiting the signal of the clients, doing the multiplication, storing the
+results on the same global variable g, and signalling to the client that the string is ready to
+be printed.
+
+The main thread waits the end on the threads, and prints the total number of served
+requests.

Lab1/D01/E01_text.pdf

@@ -0,0 +1,109 @@
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <semaphore.h>
+#include <sys/syscall.h>		//For syscall()
+#include <string.h>				//For STRCAT
+
+#define testPrintActivator 0    //Set to 1 if debug is wanted
+#define CHILDREN_NO 2
+
+void *tF (void *myFDptr);
+
+/* Section for the global variables*/
+int g;
+sem_t *s1, *s2, *s3;
+
+int main(int argc, char* argv[]){
+	int fd[CHILDREN_NO], requests = 0;
+	// To check treads creation status
+	long int rc;
+	
+	// allocating semaphores
+	s1 = (sem_t *) malloc(sizeof(sem_t));
+	s2 = (sem_t *) malloc(sizeof(sem_t));
+	s3 = (sem_t *) malloc(sizeof(sem_t));
+
+	// initializing semaphores
+	if(sem_init(s1, 0, 1) == -1){
+		fprintf(stderr, "ERROR init semaphore s1");
+	}
+	if(testPrintActivator > 0)printf("semaphore s1 initialized\n");
+	if(sem_init(s2, 0, 0) == -1){
+		fprintf(stderr, "ERROR init semaphore s2");
+	}
+	if(testPrintActivator > 0)printf("semaphore s2 initialized\n");
+	if(sem_init(s3, 0, 0) == -1){
+		fprintf(stderr, "ERROR init semaphore s3");
+	}
+	if(testPrintActivator > 0)printf("semaphore s3 initialized\n");
+
+	pthread_t tid[CHILDREN_NO];
+	//test print
+	if(testPrintActivator > 0)printf ("TEST before open files\n");
+
+	for (int i=0; i<CHILDREN_NO; i++){	
+		char path[] = "fv", path2[10];
+		sprintf(path2,"%d", i+1);
+		strcat(path2, ".b");
+		strcat(path, path2);	//Code for generating path
+		if ((fd[i] = open(path, O_RDONLY)) <0) {
+			fprintf(stderr, "error open %s\n", path);
+			return -1;
+		}
+	}
+
+	//test print
+	if(testPrintActivator > 0)	printf ("TEST before pthread_create\n");
+	// creating threads
+	for (int i=0; i<CHILDREN_NO; i++){
+		rc = pthread_create (&tid[i], NULL, tF, (void*) &fd[i]);
+		if(rc) {
+			fprintf(stderr,"ERROR: pthread_create() of thread %d with code %ld\n", i, rc );
+			exit(-1);
+		}
+	}
+    
+    int myChildCount = 0;
+	do {
+		sem_wait(s2);
+        if (g==-1) myChildCount++; 
+        else {
+            g *= 3;
+            requests++; 
+        }
+        sem_post(s3);   
+	} while (myChildCount<CHILDREN_NO);
+	
+	printf("The number of served request is: %d\n", requests);
+	/* Exit with no errors */
+	return 0;
+}
+
+void *tF (void* myFDptr){
+	//test print
+	if(testPrintActivator > 0)	printf ("Loaded thread %d .\n", syscall(SYS_gettid));
+	int number;
+	int *myFDptr2 = (int*) myFDptr;
+	int myFD = *myFDptr2;
+	while (read(myFD, &number, sizeof(int))){
+		sem_wait(s1);
+        if(testPrintActivator > 0) printf("Thread %d has read %d\n", syscall(SYS_gettid), number);
+		g = number;
+		sem_post(s2);
+
+		sem_wait(s3);
+		printf("Value %d from thread %d \n", g, syscall(SYS_gettid));
+		sem_post(s1);
+	}
+
+	sem_wait(s1);
+	g = -1;
+	sem_post(s2);
+    sem_wait(s3);
+    sem_post(s1);
+	
+	//pthread_exit(NULL);
+}

Lab1/D01/E02_text.md

@@ -0,0 +1,11 @@
+# SDP 2016/17 - Lab 1 - Davide Gallitelli S241521
+
+### E02 - Synchronization with semaphores
+
+The second part of the first lab aims at implementing a C server/client application by means of the _pthread_ library. Its purpose is to read the two binary files previously generated, fv1.b and fv2.b. Each time a value is read from a file by a thread and stored in the global variable _g_, the server multiplies that value by 3 and notifies the thread which wrote _g_ to print on the console.
+
+In order to do so, three sempahores are to be used. The first one, sempahore s1, is the one that allows client threads to run. As only one thread is supposed to be running at a time, both threads wait on the same semaphore, which is initialized to 1 - only one can enter the critical section. The first CS generates the value for _g_ by reading the next int from the file descriptor specified as parameter of the thread until EOF is reached (_read()_ returns false, condition of the _while_ is not met). Once the value is read, the semaphore s2 signals the server to do its computation - multiplication by 3 - and increase its counter of requests served. The semaphore s3 allows the thread which just generated the value to print the new computation, and then unlock any other thread waiting for s1 semaphore. 
+
+The value _g = -1_ is used as reference value for the server to understand when the thread is done reading: the computation section of the server keeps running until all clients have processed their files - represented in the code by the counter _myChildCount_ being lower than the constant _CHILDREN\_NO_.
+
+By using the _CHILDREN\_NO_ constant, this program is extremely versatile and allows for any number of clients to be launched, provided enough files (CHILDREN\_NO files, each named _fvX.b_, with X from 1 to _CHILDREN\_NO + 1_). 

Lab1/D02/E02.c

@@ -0,0 +1,5 @@
+[.ShellClassInfo]
+InfoTip=Questa cartella è condivisa online.
+IconFile=C:\Program Files (x86)\Google\Drive\googledrivesync.exe
+IconIndex=16
+