Strings producer and consumer processes

Fork two processes that create and remove 10,000 random length strings of random alphabetic characters.
Hint: use shared memory, include sys/shm.h.
See also Producer and consumer processes

SOLUTION

Download file


#include <semaphore.h> #include <sys/shm.h> #include <sys/stat.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <sys/types.h> #include <fcntl.h> #include <math.h> #include <string.h> #include <sys/mman.h> /* COMPILE: g++ process.c -lrt */ // mutex to be allocated in shared memory // so that it can be seen by two processes. sem_t * mutex; int mutexSegmentId; // Identifier // A pointer to the shared memory segment char * sharedMemory; int dataSegmentId; // Identifier // Shared index to parse the memory, it points to the first free byte int * pIndex; int indexSegmentId; // Identifier // Shared Posix Semaphores sem_t * fillCount; // Number of filled spaces in the buffer sem_t * emptyCount; // Available spaces in the buffer int sem1SegmentId; // Identifiers int sem2SegmentId; const int BUFFER_SIZE = 50; // Number of storable strings in the buffer const long TO_PRODUCE = 10000; // Strings to be produced const long TO_CONSUME = TO_PRODUCE; // Strings to be consumed const int MAX_STRING_LENGTH = 20; // Strings' maximum length // Returning a random alphabetic character char randomChar(){ return 'a' + rand() % ('z'-'a'); } // Returning a random length string, with random characters char * randomString(){ int dim = rand() % MAX_STRING_LENGTH; char * res = (char *) malloc( sizeof(char) * ( dim + 1)); int i; for( i = 0; i < dim; i++){ res[i] = randomChar(); } res[i] = '\0'; return res; } // Producer of strings void producer (long toProduce){ // Still strings to be produced while (toProduce >= 0){ // Wait if full sem_wait( emptyCount); // Waiting mutex sem_wait( mutex); /* Critical section: Producing one string */ char * toWrite = randomString(); // String to be stored strcpy( sharedMemory + *pIndex, toWrite); *pIndex = *pIndex + strlen(toWrite) + 1; // Release the mutex sem_post(mutex); // Increasing the semaphore sem_post( fillCount); toProduce--; } sem_post( fillCount); // The consumer may not finish before the producer. printf("finish prod\n"); } // Returning the length of the previous string stored in the buffer int previousStrLen(char * str, int index){ if(index < 0) return 1; else { if( str[index] == '\0') return 1; else return 1 + previousStrLen(str, index - 1); } } // From the pointer str, deleting num characters void deleteNextCharacters(char * str, int num){ for(int i = 0; i < num; i++){ str[ i]= 0; // Null } } // Consumer of strings LIFO void consumer(long toConsume, char * result){ // Still strings to be consumed while (toConsume >= 0){ // Wait if empty sem_wait( fillCount); // Waiting the mutex sem_wait(mutex); /* Critical section: Consume one string */ // Length of the previous string int prevLength = previousStrLen(sharedMemory, (*pIndex)-2); *pIndex = (*pIndex) - prevLength; // Deleting the last string in the buffer deleteNextCharacters( sharedMemory + *pIndex, prevLength); // Release the mutex sem_post( mutex); // Increasing the semaphore sem_post( emptyCount); toConsume--; } printf("finish cons\n"); } void allocateSharedMemory(){ // Allocate a shared memory segment to access the mutex mutexSegmentId = shmget( IPC_PRIVATE, sizeof(sem_t), S_IRUSR | S_IWUSR); mutex = ( sem_t *)shmat ( mutexSegmentId, NULL, 0); // Attaching the shared memory segment // Allocate the shared memory segment where strings will be produced and consumed dataSegmentId = shmget( IPC_PRIVATE, BUFFER_SIZE * (MAX_STRING_LENGTH * sizeof(char)), S_IRUSR | S_IWUSR); sharedMemory = (char*) shmat( dataSegmentId, NULL, 0); // Attaching the shared memory segment // Allocate a shared memory segment to access the index indexSegmentId = shmget( IPC_PRIVATE, sizeof(int), S_IRUSR | S_IWUSR); pIndex = (int *) shmat( indexSegmentId, NULL, 0); // Allocate a shared memory segment to access the semaphores sem1SegmentId = shmget( IPC_PRIVATE, sizeof(sem_t), S_IRUSR | S_IWUSR); sem2SegmentId = shmget( IPC_PRIVATE, sizeof(sem_t), S_IRUSR | S_IWUSR); fillCount = (sem_t *) shmat( sem1SegmentId, NULL, 0); emptyCount = (sem_t *) shmat( sem2SegmentId, NULL, 0); } void deallocateSharedMemory(){ // Detaching the shared memory segments shmdt(sharedMemory); shmdt(mutex); shmdt(pIndex); shmdt(fillCount); shmdt(emptyCount); // Removing shared memory segments shmctl(dataSegmentId, IPC_RMID, NULL); shmctl(mutexSegmentId, IPC_RMID, NULL); shmctl(indexSegmentId, IPC_RMID, NULL); shmctl(sem1SegmentId, IPC_RMID, NULL); shmctl(sem2SegmentId, IPC_RMID, NULL); } void initializeVariables(){ // Initialize the mutex sem_init(mutex, 1, 1); // Initialize the index *pIndex = 0; /* Initialize the semaphores * Second argument: more than one process will access it * Third argument: initialization value (empty buffer) */ sem_init( fillCount, 1, 0); sem_init( emptyCount, 1, BUFFER_SIZE); } // Writing a file of the specified length containing all 0 void makefile(const char * filename, int length){ // New File FILE * fileToWrite; fileToWrite = fopen( filename,"w"); if( fileToWrite != NULL){ for(int i = 0; i < length; i++){ fputc('0',fileToWrite); } } fclose(fileToWrite); } int main(){ allocateSharedMemory(); initializeVariables(); // Forking the two processes int pid = fork(); if (pid < 0) perror("fork failed "); else if (pid == 0){ // child producer(TO_PRODUCE); } else{ // parent consumer(TO_CONSUME); } deallocateSharedMemory(); return 0; } <textarea/> <br /> Exercise from <a href="http://www.csd.abdn.ac.uk/~jrl/teach/CS3008/base.htm" target="_blank">CS3008</a> <strong><span style="font-size: large;"><br /></span></strong>

Excercise from CS3008

Producer and consumer processes

Fork two processes which share a common 4KB area of memory. One process should produce 10 million bytes, the other should consume them.
Hint: use shared memory, include sys/shm.h. Think to what is fork function doing.

SOLUTION

Download the file here

#include <semaphore.h> #include <sys/shm.h> #include <sys/stat.h> #include <stdio.h> #include <sys/mman.h> #include <unistd.h> #include <stdlib.h> #include <sys/types.h> #include <fcntl.h> /* COMPILE: g++ process.c -lrt */ // mutex to be allocated in shared memory // so that it can be seen by two processes. sem_t * mutex; int mutexSegmentId; // Identifier // A pointer to the shared memory segment char * sharedMemory; int dataSegmentId; // Identifier // Shared index to parse the memory int * pIndex; int indexSegmentId; // Identifier // Shared Posix Semaphores sem_t * fillCount; // Number of filled spaces in the buffer sem_t * emptyCount; // Available spaces in the buffer int sem1SegmentId; // Identifiers int sem2SegmentId; // Elements to be produced const long TO_PRODUCE = 10000000; const long TO_CONSUME = TO_PRODUCE; const int MEMORY_SIZE = 4096; // Producer of bytes void producer (long toProduce) { // Still bytes to be produced while (toProduce >= 0){ char producedByte = '1'; // Wait if full sem_wait( emptyCount); // Waiting mutex sem_wait( mutex); /* Critical section: Produce one byte */ sharedMemory[ *pIndex] = producedByte; *pIndex = *pIndex + 1; // Release the mutex sem_post(mutex); // Increasing the semaphore sem_post( fillCount); toProduce--; } sem_post( fillCount); // The consumer may not finish before the producer. printf("Successfully produced %lu bytes\n", TO_PRODUCE); } // Consumer of bytes LIFO void consumer(long toConsume) { while (toConsume >= 0){ // Still strings to be produced // Wait if empty sem_wait( fillCount); // Waiting the mutex sem_wait(mutex); /* Critical section: Consume one byte */ // Deleting the last byte of the buffer *pIndex = *pIndex - 1; sharedMemory[ *pIndex] = 0; // Release the mutex sem_post( mutex); // Increasing the semaphore sem_post( emptyCount); toConsume--; } printf("Successfully consumed %lu bytes\n", TO_CONSUME); } void allocateSharedMemory(){ // Allocate a shared memory segment to access the mutex mutexSegmentId = shmget( IPC_PRIVATE, sizeof(sem_t), S_IRUSR | S_IWUSR); mutex = ( sem_t *)shmat ( mutexSegmentId, NULL, 0); // Attaching the shared memory segment // Allocate the shared memory segment where bytes will be produced and consumed dataSegmentId = shmget( IPC_PRIVATE, MEMORY_SIZE, S_IRUSR | S_IWUSR); sharedMemory = (char *) shmat( dataSegmentId, NULL, 0); // Attaching the shared memory segment // Allocate a shared memory segment to access the index indexSegmentId = shmget( IPC_PRIVATE, sizeof(int), S_IRUSR | S_IWUSR); pIndex = (int *) shmat( indexSegmentId, NULL, 0); //Allocate a shared memory segment to access the semaphores sem1SegmentId = shmget( IPC_PRIVATE, sizeof(sem_t), S_IRUSR | S_IWUSR); sem2SegmentId = shmget( IPC_PRIVATE, sizeof(sem_t), S_IRUSR | S_IWUSR); fillCount = (sem_t *) shmat( sem1SegmentId, NULL, 0); emptyCount = (sem_t *) shmat( sem2SegmentId, NULL, 0); } void deallocateSharedMemory(){ // Detaching the shared memory segments shmdt(sharedMemory); shmdt(mutex); shmdt(pIndex); shmdt(fillCount); shmdt(emptyCount); // Removing shared memory segments shmctl(dataSegmentId, IPC_RMID, NULL); shmctl(mutexSegmentId, IPC_RMID, NULL); shmctl(indexSegmentId, IPC_RMID, NULL); shmctl(sem1SegmentId, IPC_RMID, NULL); shmctl(sem2SegmentId, IPC_RMID, NULL); } void initializeVariables(){ // Initialize the mutex sem_init(mutex, 1, 1); // Initialize the index *pIndex = 0; /* Initialize the semaphores * Second argument: more than one process will access it * Third argument: initialization value (empty buffer) */ sem_init( fillCount, 1, 0); sem_init( emptyCount, 1, MEMORY_SIZE); } // Writing a file of the specified length containing all 0 void makefile(const char * filename, int length){ // New File FILE * fileToWrite; fileToWrite = fopen( filename,"w"); if( fileToWrite != NULL){ for(int i = 0; i < length; i++){ fputc('0',fileToWrite); } } fclose(fileToWrite); } int main() { allocateSharedMemory(); initializeVariables(); // Forking the two processes int pid = fork(); if (pid < 0) perror("fork failed "); else if (pid == 0){ // child // Starting producing producer(TO_PRODUCE); } else{ // parent // Starting consuming consumer(TO_CONSUME); } deallocateSharedMemory(); return 0; } <textarea/>

Exercise from CS3008

Write a ppm file picture

Write a picture ppm file to memory.
To make it faster, use mmap so that the memory writes itself back to a file at the end.

#include <sys/mman.h> #include <unistd.h> #include <assert.h> #include <stdlib.h> #include <string.h> const int COLOR_NO = 256; // Pixel color range const int MAX_COLOR = COLOR_NO - 1; const int COLUMNS = 30; // Pixel Columns number const int ROWS = 30; // Pixel Rows number const int STRING_DIM = COLUMNS * ROWS * 20; // Big enough const char filename[] = "newPic.ppm"; // Destination file // New file of the specified size void makeNewFile(const char * filename, int length){ // New File FILE * fileToWrite; fileToWrite = fopen( filename,"w"); if( fileToWrite != NULL){ for(int i = 0; i < length; i++){ fputc(' ',fileToWrite); } } fclose(fileToWrite); } // Making a String in ppm format: http://netpbm.sourceforge.net/doc/ppm.html void createPpmFormat(char * res){ res = strcat(res, "P3\n"); // Ppm format char temp[STRING_DIM]; // A string Big enough sprintf(temp,"%d %d\n%d\n",COLUMNS, ROWS, MAX_COLOR); // Ppm dimension and color strcat(res, temp); int a[3]; for(int i = 0; i < ROWS; i++){ // Randomly coloring pixels for(int j = 0; j < COLUMNS; j++){ a[0] = rand() % COLOR_NO; a[1] = rand() % COLOR_NO; a[2] = rand() % COLOR_NO; sprintf(temp," %d %d %d ", a[0],a[1],a[2]); strcat(res,temp); } strcat(res,"\n"); } } int main() { makeNewFile( filename, STRING_DIM); // Creating a file big enough int f = open(filename, O_RDWR); // read - write assert ( f >=0); // newPic.ppm must exist before this starts. Its contents will be changed. char * pos = (char*) mmap(0, STRING_DIM + 1, PROT_READ | PROT_WRITE, MAP_SHARED, f, 0); assert (pos != MAP_FAILED); char * ppmFormat = (char*)malloc(sizeof(char) * (STRING_DIM+1)); createPpmFormat( ppmFormat); // Writing the ppm format string in memory for (int j = 0 ; j < STRING_DIM; ++j) pos[j] = ppmFormat[j]; printf("\n"); return 0; } <textarea/>

Reading man pages

The manual page for getpwuid says, among other things
#include <pwd.h>

struct passwd *getpwuid(uid_t uid);

The passwd structure is defined as follows:

struct passwd {
char *pw_name; /* user name */
char *pw_passwd; /* user password */
uid_t pw_uid; /* user ID */
gid_t pw_gid; /* group ID */
char *pw_gecos; /* real name */
char *pw_dir; /* home directory */
char *pw_shell; /* shell program */
};

 1. Where is struct passwd defined?

 2. What is uid_t?

 3. Write a minimum C program to print your real name and your user name

SOLUTION
1) A definition for struct passwd is provided by the <pwd.h> header

2) uid_t is a type defined by <sys/types.h> used for numerical user ID


3)
#include <unistd.h> #include <pwd.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <string.h> int main(){ struct passwd * myPwd = getpwuid( getuid()); printf("real name: %s\n", myPwd -> pw_gecos;); printf("user name: %s\n", myPwd -> pw_name); } ./a.out : real name: Jack Smith, student user name: cs01js2

Exercise from: CS3008

Create a file with C

Write void makefile(const char * filename, int length); which writes a file of the specified length. The contents of the file should all be 0.

#include <stdio.h> #include <stdlib.h> // Writing a file of the specified length containing all 0 void makefile(const char * filename, int length){ // New File FILE * fileToWrite; fileToWrite = fopen( filename,"w"); if( fileToWrite != NULL){ for(int i = 0; i < length; i++){ fputc('0',fileToWrite); } } fclose(fileToWrite); } int main(){ makefile("newFile0",0); makefile("newFile1",1); makefile("newFile40129",40129); }

Exercise from: CS3008

C char and string

An easy exercise to get in touch with C char and strings handling

Write
void show( const char s[])
which prints the ascii values of the first ten chars in s.

Write a function
int mylen( const char * s)
which returns the useful length of the string s. C strings are terminated by a zero char.
Please do not use strlen from the string.h library, but write it with raw C. [1]

Test this with several examples, including the null string "".

Use your function as part of a program to count the number of 4 letter words typed to it. The central part is
char buff[100];
while (scanf(" %s", buff) != EOF){
// do something with buff, which should hold
// a zero-terminated string.
}
a.out expects you to type words to it, followed by an end of file (CTRL-D).

Try
cat /usr/dict/words | a.out

SOLUTION


#include <stdio.h>
void show(const char s[]){
         int i = 0;
          while(i<10){
                    printf("%d\n",s[i]);
                    i++;
          }
}

int mylen( const char * s){
          int cont = 0;
          while(s[cont]!='\0'){
                    cont++;
          }
          return cont;
}

int countFourLettersWords(){
          char buff[100];
          int cont = 0;
          while(scanf("%s",buff)!= EOF){
                    if(mylen(buff)==4)
                              cont++;
          }
          return cont;
}

int main(){
          char s[]="Hello world";
          char empty[]="";
          char num[]="01234";
          show(s);
          printf("Length:\n %d\n",mylen(s));
          show(empty);
          printf("Length:\n %d\n",mylen(empty));
          show(num);
          printf("Length:\n %d\n",mylen(num));
          printf("I will count the four letters words:\n");
          printf("%d \n",countFourLettersWords());
          getchar();
}

Exercise from: CS3008

Structs

Little exercise to test yor skills with C structs


- 1)  From the C statement
                A[j].data[k] = 63;
                What do we know about the types of
                j
                k
                data
                A

- 2) Write a definition for A which will make the statement syntactically acceptable.

- 3) Write a function to fill your version of A with a different value in every cell.

Possible Solution


- 1) 
              j int               k int               data int *               A pointer to a structure TCell (see below)



- 2)
              typedef struct TCell *Array;
              struct TCell{
              int * data;
              }
              Array A;


- 3)
typedef struct TCell *Array;
struct TCell{
            int * data;
}
int main(){
            int arrayDim = 10;
            int dataDim = 5;
            Array A = (Array)malloc(sizeof(struct TCell)*10);
            int * data = (int *)malloc(sizeof(int)*dataDim);
            for(int j=0; j < arrayDim; j++){
                        A[j].data = (int *)malloc(sizeof(int)*dataDim);
                        for( int k = 0; k < dataDim; k++){
                                    A[j].data[k] = rand()%100;
                        }
            }
}


Exercise from: CS3008