initial commit

Author: TeoMal

HW.pdf

@@ -0,0 +1,18 @@
+
+server: ./src/server.c client ./src/helpers.c
+	gcc -g -pthread -Wall ./src/server.c ./src/helpers.c -o $@
+
+client: ./src/client.c ./src/helpers.c
+	gcc -g -pthread -Wall ./src/client.c ./src/helpers.c -o $@
+
+clean:
+	rm -f server client && rm -f ./logs/*.txt && clear
+
+clear:
+	rm -f server client && rm -f ./logs/*.txt && clear
+
+reset:
+	rm -f server client && rm -f ./logs/*.txt && killall client && clear
+	
+run: server client
+	./server test.txt 2 10

Makefile

@@ -0,0 +1,33 @@
+# Inter Process Communication
+
+This repository contains an OS assigment concerning IPC and its solution. To better understand what the program does I suggest you read the assignment first, however it is written in Greek, so for those who don't know Greek there is a summary in English below.
+
+# Assignment
+
+Create a program that has one parent process and N child processes that read/write from a buffer. The parent process has access to a .txt file from which it writes a specific segment to the buffer and only it can write in the buffer, also the child processes may only read from the buffer. Multiple children can read at a time but the parent can't write when there is at least one child still reading. The way children read is by sending requests about a specific segment from  the  .txt file and a specific line from the segment,if the segment they are requesting is the one currently at the buffer they may read the line, if not they wait in Queue for the segment to change. The strategy used to change segments is a simple FIFO strategy. The server(parent process) will change the segment only when there is no other request for the current segment available and there are child processes waiting for some other segment.The .txt file to read from as well as the number of lines each segment of the .txt file will contain and the number of requests each child will make are passed as arguments when running the executable(e.g ./server test.txt 2 2 will read from test.txt with each segment containing 2 lines and each child sending 2 requests). The way child processes create requests is as follows with 30% probability choose a new random segment,with 70% probability choose the segment of your previous request, the line requested from the segment is completely random. After each request each child process will write in its log file the time it took to get the requested line and the server logs when each segment entered the buffer and when each segment exited the buffer.
+
+# Compiling and running
+
+To compile the files run ` make ` and to run the executable ` server ` type ` ./server file.txt X Y `  where file.txt is the file from which lines will be requested, X is an integer that tells us how many lines each segment will have and Y is an integer that corresponds to the amount of requests each child process will make.As an example run ` make run ` to see the program running with the file ` test.txt ` and 2 lines per segment and 10 requests per child. In order the clean the log files  and .o files run `make clean`.
+
+# Server
+The server in this implementation is only responsible for changing the segment currently inside the buffer. Before the main loop begins the server calls the helper functions to get the number of lines per segment,the maximum line and the number of requests per child. After that it initiates the semaphores as well as the shared memory(posix library used). For shared memory we use a struct shared_obj which holds information about the segment currently in use,the next segment to be put as well as the number of children waiting in queue, in addition we have a shared memory string that will be used as our buffer. To synchronize the processes we use 4 semaphores:
+- `write_server`: signals the server so that it changes the segment to the next requested segment or quits if all children are done requesting.
+- `ready`: signals to the child processes that the server is done changing the segment and they may continue reading.
+- `critical`: mutex semaphore used so only one process writes at the shared_obj struct.
+- `queue`: semaphore used to block child processes that are waiting in queue.
+
+After the initialization of the semaphores and the shared memory the server starts creating child processes and waits for the signal to change the current segment. After all childrens' requests have been granted the server is signaled to exit.
+
+
+# Client
+Each client runs the file `client.c` where lines per segment,max line and total requests are passed as arguments as well as the id of the shared_obj, After linking to the shared memory and to the named semaphores the client starts sending requests in a loop until they have completed sending the requests.
+- If the flag `new` is set to 1 then the client makes a new request
+- Then they check whether the current segment is the same as the one they are requesting
+- If it is they read the line and `continue` to create another request
+- If it isn't they go to wait in the queue. In case they are the first to enter the queue they change the `next_seg` to their requested segment and wait in the queue. In case by them going to the queue now all alive processes(meaning all client processes still running) are waiting in the queue they signal the server to change the segment and they release all the other processes from the blocked semaphore. At the end they release the `critical` mutex semaphore so other clients can enter the queue.
+
+After exiting the loop and completing the requests they check the following:
+- If by them exiting now all other processes are waiting in queue they signal the server and release the other children.
+- In the other case that they are the last child process to exit they signal the server to also exit from the loop of changing segments.
+

README.md

@@ -0,0 +1,5 @@
+char* get_line(const char* str, int line_num);
+void get_request(int old_sec, int *req_line, int *req_sec, int total_lines, int lines_per_sec, int max_sec);
+char *get_sector(char *source,int sector,int lines_per_sector,int max_line);
+int get_max_line(char *file);
+int get_lines(char *file);

include/helpers.h

@@ -0,0 +1,13 @@
+#define WR_SERV "/server123"
+#define READY "/ready123"
+#define CS "/critical123"
+#define QUEUE "/fqueue123"
+#define N 10
+#define SEM_PERMS (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP )
+typedef struct shared_obj{
+    int ID_str;
+    int in_q;
+    int curr_seg;
+    int next_seg;
+    int dead;
+}shared_obj;

include/struct.h

@@ -0,0 +1 @@
+Folder to store logs from clients and server

logs/Readme.md

@@ -0,0 +1,153 @@
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <errno.h>
+#include "../include/struct.h"
+#include"../include/helpers.h"
+int main(int argc, char **argv)
+{
+    //Initialize Random generator based on pid so each process has a different rand
+    srand(time(NULL) - getpid());
+    clock_t start, end;
+    //Temporarily create a string to open a log file
+    char *proc_id = malloc(sizeof(char) * 100);
+    if(proc_id==NULL){
+        perror("malloc at proc_id");
+        exit(20);
+    }
+    sprintf(proc_id, "./logs/%d_log.txt", getpid());
+    
+    //Delete previous log file in case proccess id is the same as a previous one
+    if(remove(proc_id)==0){
+        printf("Removed File succcessfully\n");
+    }
+    
+    FILE *logs;
+    //Get necessary integers from arguments
+    int id = atoi(argv[0]);         //Id for memory block
+    int max_sec = atoi(argv[1]);    //Number of sections
+    int max_line = atoi(argv[2]);   //Number of chars in max line
+    int loop = atoi(argv[3]);       //Total requests to be sent
+    int total_lines = atoi(argv[4]);    //Total lines in each segment
+    char *line;
+    if (id == 0)
+    {
+        perror("Error at getting shm id from parent");
+        exit(14);
+    }
+    //Attach memory
+    shared_obj *memory = (shared_obj *)shmat(id, NULL, 0);
+    if (memory == (void *)-1)
+    {
+        perror("Attachment.");
+        exit(15);
+    }
+    // Attach shared string
+    char *shared_string = (char *)shmat(memory->ID_str, NULL, 0);
+    if(shared_string==(char *)-1){
+        perror("Error at attaching child to shared_string");
+        exit(16);
+    }
+
+    //Open created semaphores for usage
+    sem_t *write_server = sem_open(WR_SERV, 0);
+    sem_t *ready = sem_open(READY, 0);
+    sem_t *critical = sem_open(CS, 0);
+    sem_t *queue = sem_open(QUEUE, 0);
+
+    //Variables needed
+    int new = 1,old_req=-1,req_line,req_sec;
+    
+    while (loop > 0)
+    {
+        //Create a new request
+        if (new == 1)
+        {
+            get_request(old_req, &req_line, &req_sec, total_lines, max_line, max_sec);
+            start = clock();
+            old_req = req_sec;
+            printf("Client: %d made request <%d,%d>\n", getpid(), req_line, req_sec);
+            fflush(stdout);
+            //Make new 0 so that if the loop come backs we dont create a new request and discard current
+            new = 0;
+        }
+        
+        //In case requested segment is current segment go ahead and read
+        if (req_sec == memory->curr_seg)
+        {
+            end = clock();      //Stop Clock
+            line = get_line(shared_string, req_line);       //Read requested line
+            logs = fopen(proc_id, "a");      //Open log file in log folder
+            fprintf(logs, "Response Time:%fs,<%d,%d>,Line:%s\n", ((double)(end - start)) / CLOCKS_PER_SEC, req_line, req_sec, line); //Write in logs
+            printf("Client: %d got request <%d,%d>\n", getpid(), req_line, req_sec);    //Print to let user know that request got completed
+            loop--;             //One request done
+            new = 1;            //Create new request
+            fclose(logs);
+            usleep(20000);      //Sleep for 20ms
+            continue;
+        }
+        else
+        {
+            //In case current section available isn't requested section wait for critical section
+            //to change the variable in memory
+            sem_wait(critical);
+            printf("Client: %d got queued\n", getpid());
+            fflush(stdout);
+            //If u are first to enter Queue make your requested segment the next to be put
+            if (memory->in_q == 0)
+            {
+                memory->next_seg = req_sec;
+                printf("Server: Next segment will be %d\n", memory->next_seg);
+                fflush(stdout);
+            }
+
+            //Increase the number of processes waiting in queue
+            memory->in_q++;
+            if (memory->in_q == (N - memory->dead))
+            {
+                memory->in_q--;
+                //In case the Queue is now full with all alive processes call server to change segment
+                sem_post(write_server);
+                sem_wait(ready);
+                //Give critical to the next process
+                sem_post(critical);
+            }
+            else
+            {
+                //If you Queue isn't Full give back critical and wait in Queue
+                sem_post(critical);
+                sem_wait(queue);
+            }
+        }
+    }
+
+    //process exits and waits for critical to update number of dead processes
+    sem_wait(critical);
+    memory->dead++;
+    
+    //In Case Queue is now full because all other processes are waiting in Queue or all processes are dead
+    //change Segment and unblock
+    
+    if (memory->in_q == N - memory->dead)
+    {
+        //Post to server so that segment updates
+        sem_post(write_server);
+        sem_wait(ready);
+
+    }
+    //Give back critical
+    sem_post(critical);
+    
+    //Close open File and exit
+    free(proc_id);
+    return 0;
+}