Merge branch 'VictorRodriguez:main' into main

Author: Oswaldo Hernandez

labs/04/README.md

@@ -8,11 +8,13 @@ Develop the skills to program an application that solves a problem using threads
 * Linux machine, either a VM or a baremetal host
 * GCC compiler (at least version 4.8)
 * shell scripting
+* git send mail server installed and configured on your Linux machine
 
 ## Instructions
 
 * Clone the repository
-* Go to labs/04
+* Go to operating-systems-lecture/labs/04
+* Read examples from operating-systems-lecture/labs/04
 * Calculate the value of Pi ( 3.141596 ) using this algorithm:
 
 ```
@@ -34,7 +36,7 @@ PI = 4.0*circle_count/npoints
 
 more info: https://computing.llnl.gov/tutorials/parallel_comp/ )
 
-Please send the code as Pull request and include in the comments of the code (at
+Please send the code as a patch and include in the comments of the code (at
 the top), the results in terms of a link to a graph that shows the speed
 improvements, how much time does it take to calculate pi with 1 thread, 2
 threads 4 threads 8 threads and 16 threads?
@@ -64,9 +66,16 @@ the link could be to a google documents pdf. please create good graphs:
 3.151596...
 ```
 
-## How to do a pull request:
-https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request
+## Please send the mail as git send mail:
 
+```
+$ git add my_terminal.c
+$ git commit -s -m <STUDENT-ID>-homework-04
+$ git send-email -1
+
+```
+Do some tests sending the mail to your personal account, if you get the mail,
+then you can be sure I will get the mail
 
 # Time to do the homework:
 

labs/04/findCircle

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+int main(){
+    double r=0.5;
+    double x=0.5;
+    double y=0;
+
+    double d = pow(r,2) - (pow(x,2) + pow(y,2));
+    printf("d = %f \n", d);
+
+    if(d>0){
+        printf("inside");
+    }else if(d==0){
+        printf("on the circumference");
+    }else{
+        printf("outside");
+    }
+}

labs/04/findCircle.c

@@ -0,0 +1,96 @@
+/*
+Link a grafica:
+https://docs.google.com/spreadsheets/d/193QjARyWOg6bN4Dingg4aaYqNGzAMB6qSqdAcy1Kqfw/edit?usp=sharing
+
+Autor:
+Andres Remis Serna A00829053
+
+Con apoyo de los siguientes repositorios:
+https://github.com/VictorRodriguez/operating-systems-lecture/blob/master/labs/04/pi.c
+https://github.com/VictorRodriguez/operating-systems-lecture/blob/master/labs/04/mutex-thread.c
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <time.h>
+
+#define NUM_THREADS   75
+
+int npoints = 100000;
+int circle_count = 0;
+double radius=1;
+pthread_mutex_t lock;
+int pointsThread;
+
+
+/*https://github.com/VictorRodriguez/operating-systems-lecture/blob/master/labs/04/pi.c */
+
+unsigned int seed;
+
+double r2(){
+    return (double)rand_r(&seed) / (double)((unsigned)RAND_MAX + 1);
+}
+
+/*fin github*/
+
+int find_circle(double x, double y){
+
+    double d = pow(radius,2) - (pow(x,2) + pow(y,2));
+
+    if(d>=0){
+        return 1;
+    }else{
+        return 0;
+    }
+}
+
+void * Count(void * a){
+    int cont=0;
+    pthread_mutex_lock(&lock);
+    for (int j=1; j<=pointsThread; j++){
+        //generate 2 random numbers between 0 and 1
+        double xcoordinate = r2();
+        double ycoordinate = r2();
+        int circ=find_circle(xcoordinate,ycoordinate);
+        if (circ==1) {
+            circle_count = circle_count + 1;
+        }else{
+            cont++;//end do
+        }
+    }
+    pthread_mutex_unlock(&lock);
+    return NULL;
+}
+
+int main(int argc, char *argv[]){
+    clock_t start, end;
+    double cpu_time_used;
+
+    start = clock();
+    if (pthread_mutex_init(&lock, NULL) != 0){
+        printf("\n mutex init failed\n");
+            return 1;
+    }
+    //do j = 1,npoints
+    seed = time(NULL);
+
+    pthread_t threads[NUM_THREADS];
+    pointsThread= npoints/NUM_THREADS;
+
+
+    for(int i=0; i<NUM_THREADS; i++){
+        pthread_create(&threads[i], NULL, Count, NULL);
+    }
+
+    for(int i=0; i<NUM_THREADS; i++){
+        pthread_join(threads[i], NULL);
+    }
+
+    double PI = 4.0*(double)circle_count/(double)npoints;
+    end = clock();
+    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+    printf("PI = %f\nTime used=%f",PI, cpu_time_used);
+    pthread_mutex_destroy(&lock);
+}

labs/04/mutex-thread

@@ -0,0 +1,64 @@
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NITER 1000000
+
+int cnt = 0;
+
+pthread_mutex_t lock;
+
+void * Count(void * a){
+    pthread_mutex_lock(&lock);
+    int i, tmp;
+    for(i = 0; i < NITER; i++)
+    {
+        tmp = cnt;      /* copy the global cnt locally */
+        tmp = tmp+1;    /* increment the local copy */
+        cnt = tmp;      /* store the local value into the global cnt */
+    }
+    pthread_mutex_unlock(&lock);
+    return NULL;
+}
+
+int main(int argc, char * argv[])
+{
+    pthread_t tid1, tid2;
+
+    if (pthread_mutex_init(&lock, NULL) != 0){
+        printf("\n mutex init failed\n");
+            return 1;
+    }
+
+    if(pthread_create(&tid1, NULL, Count, NULL))
+    {
+      printf("\n ERROR creating thread 1");
+      exit(1);
+    }
+
+    if(pthread_create(&tid2, NULL, Count, NULL))
+    {
+      printf("\n ERROR creating thread 2");
+      exit(1);
+    }
+
+    if(pthread_join(tid1, NULL))    /* wait for the thread 1 to finish */
+    {
+      printf("\n ERROR joining thread");
+      exit(1);
+    }
+
+    if(pthread_join(tid2, NULL))        /* wait for the thread 2 to finish */
+    {
+      printf("\n ERROR joining thread");
+      exit(1);
+    }
+
+    if (cnt < 2 * NITER)
+        printf("\n BOOM! cnt is [%d], should be %d\n", cnt, 2*NITER);
+    else
+        printf("\n OK! cnt is [%d]\n", cnt);
+
+    pthread_mutex_destroy(&lock);
+}

labs/04/practice1

@@ -0,0 +1,58 @@
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NITER 1000000
+
+int cnt = 0;
+
+void * Count(void * a)
+{
+    int i, tmp;
+    for(i = 0; i < NITER; i++)
+    {
+        tmp = cnt;      /* copy the global cnt locally */
+        tmp = tmp+1;    /* increment the local copy */
+        cnt = tmp;      /* store the local value into the global cnt */
+    }
+}
+
+int main(int argc, char * argv[])
+{
+    pthread_t tid1, tid2;
+
+    if(pthread_create(&tid1, NULL, Count, NULL))
+    {
+      printf("\n ERROR creating thread 1");
+      exit(1);
+    }
+
+    if(pthread_create(&tid2, NULL, Count, NULL))
+    {
+      printf("\n ERROR creating thread 2");
+      exit(1);
+    }
+
+    if(pthread_join(tid1, NULL))    /* wait for the thread 1 to finish */
+    {
+      printf("\n ERROR joining thread");
+      exit(1);
+    }
+
+    if(pthread_join(tid2, NULL))        /* wait for the thread 2 to finish */
+    {
+      printf("\n ERROR joining thread");
+      exit(1);
+    }
+
+    if (cnt < 2 * NITER)
+        printf("\n BOOM! cnt is [%d], should be %d\n", cnt, 2*NITER);
+    else
+        printf("\n OK! cnt is [%d]\n", cnt);
+
+    pthread_exit(NULL);
+}
+
+
+

labs/04/practice1.c

@@ -0,0 +1,66 @@
+
+#
+# Round Robin calculator
+#
+# Simulate the Round Robin mechanism based on a queue of processes
+# Print the Avg turn around time
+#
+# It can be used from command line
+#
+# process = [] might be a random list of elapsed times
+#
+# Experiment with this and make 3D graphs for:
+#
+#   avg_turn_time vs quantum vs max process size
+#
+
+import sys, getopt
+
+def main(argv):
+
+    quantum = 4
+    context_switch = 2
+    execution_time = 0
+    avg_turnaround_tm = 0.0
+    context_switchs = 0
+
+    processes =[2,3,4,12,8,5,6,1]
+    num_processes = len(processes)
+
+    try:
+        opts, args = getopt.getopt(argv,"hq:",["quantum_time="])
+    except getopt.GetoptError:
+        print("round_robin.py -q <quantum time>")
+        sys.exit(-1)
+    for opt, arg in opts:
+        if opt == '-h':
+            print ("test.py -q <quantum time>")
+            sys.exit()
+        elif opt in ("-q", "--quantum_time"):
+            quantum = int(arg)
+
+    for process in processes:
+        if process <= quantum:
+            print("process executed")
+            execution_time+=process
+            print("execution time " + str(execution_time))
+        else:
+            print("process interrupted")
+            remain_time = process - quantum
+            context_switchs+=1
+            print("time process executed: "+ str(quantum))
+            execution_time+=quantum
+            execution_time+=context_switch
+            print("execution time " + str(execution_time))
+            processes.append(remain_time)
+
+        print(processes)
+        print()
+
+    avg_turnaround_tm = float(execution_time)/float(num_processes)
+    print ("Number of processes : " + str(num_processes))
+    print ("Number of context switch : " + str(context_switchs))
+    print ("Avg turn around time : " + str(avg_turnaround_tm))
+
+if __name__ == "__main__":
+   main(sys.argv[1:])