Threads and Processes Management

Threads and Processes Management #

Two programs simulating a handler that manages threads/processes through signals.

Makefile#

Run ‘make’ to compile all the binaries.
Run ‘make clean’ to clean up all the compiled binaries.

Thread and Process Management#

After compiling, run with ./threads or ./procs

The program will read in from ‘config.txt’ and use the value inside to determine how many worker processes are needed.

The handler ID will be printed out, so you can send signals to it through the command line.

Both programs create a handler, and several children processes/threads that will ‘work’ until they receive a signal to stop working

Sending the handler the SIGINT signal results in the handler telling all workers to clean up and exit and then the handler exiting itself

Sending the handler the SIGHUP signal results in the handler re-reading the config file and changing the number of running workers, either creating more, or removing some.

Code#

1
//-----------------------------------------
2
// NAME: Ryan Dotzlaw
3
//
4
// REMARKS: Managing processes and communication with signals
5
//
6
//-----------------------------------------
7

8
#include <stdio.h>
9
#include <signal.h>
10
#include <string.h>
11
#include <unistd.h>
12
#include <sys/wait.h>
13
#include <stdlib.h>
14

15
//-----------------------------------------
16
// Function declarations
17
//-----------------------------------------
18

19
// A function for reading "config.txt"
20
void config();
21
// A function to update the number of workers
22
void update_w();
23
// A function to create a single worker and add it to the end of the workers array
24
void create_w();
25
// A function to remove a single worker from the end of the workers array
26
void remove_w();
27
// A function to keep the workers busy
28
void work();
29
// A function that is called by workers when they're cleaning up and exiting
30
void worker_clean();
31
// A function called by the handler when it's time to clean up all workers and shutdown
32
void handler_clean();
33

34
//-----------------------------------------
35
// Data declarations
36
//-----------------------------------------
37

38
typedef struct HANDLER {
39
  // The maximum number of workers, or rather, the number of workers to have
40
  int num_workers;
41
  // The current number of workers running (length of workers array)
42
  // If this is different from num_workers, need to add/remove workers
43
  int cur_workers;
44
  // A list of all processes
45
  pid_t workers[];
46
} handler;
47

48
// Config filename
49
static char* FILE_NAME = "config.txt";
50

51
// Initialize handler struct
52
handler h;
53

54
//-----------------------------------------
55
// Function definitions
56
//-----------------------------------------
57

58
//------------------------------------------------------
59
// config
60
// * Only for use by the handler
61
// PURPOSE: Reads the file "config.txt" when called and updates the
62
//      value: 'num_workers' in the 'h' struct.
63
//      Then calls 'update_w'
64
//------------------------------------------------------
65
void config(){
66
  printf(" * Beginning to read config file...\n");
67

68
  int buf;
69

70
  // open config in read only mode
71
  FILE *f = fopen(FILE_NAME, "r");
72

73
  // read in the number of workers
74
  // can be in range [0,9], simply because I don't want to deal w/ converting a string to an int or whatever
75
  buf = fgetc(f) - '0'; // - '0' converts char number to int number
76
  printf(" * New number of workers: %d\n", buf);
77
  h.num_workers = buf;
78

79
  fclose(f);
80
  printf(" * Done reading config file.\n");
81
  update_w();
82
  // Done reading config and updating
83
  // handler can return to whatever it was doing before interrupt
84
}
85

86
//------------------------------------------------------
87
// update_w
88
// * Only for use by the handler
89
// PURPOSE: Uses the handler struct 'h', and it's associated
90
//      values: 'num_workers' and 'cur_workers' to decide
91
//      whether to create/remove workers and how many.
92
//------------------------------------------------------
93
void update_w(){
94

95
  printf(" * * Beginning to update workers\n");
96
  int difference = h.num_workers - h.cur_workers;
97
  // for output
98
  int d = abs(difference);
99
  if(difference == 0){ // No difference, no need for updates
100
    printf(" * * No new workers were created\n");
101
    // Handler goes back to idling
102

103
  } else if(difference > 0){ // difference positive, need to create more workers
104

105
    // create 'difference' more workers
106
    while(difference != 0){
107
      create_w();
108
      difference--;
109
    }
110
    printf(" * * %d new workers were created.\n",d);
111

112
  } else { // difference negative, need to remove workers
113

114
    // remove 'abs(difference)' workers
115
    while(difference != 0){
116
      remove_w();
117
      difference++;
118
    }
119
    printf(" * * %d workers were removed.\n",d);
120

121
  }
122
  // All changes are done, handler will return to config function call
123
}
124

125
//------------------------------------------------------
126
// create_w
127
// * Only for use by the handler
128
// PURPOSE: A helper function for 'update_w', creates a single worker
129
//      and appends it to the end of the 'workers' array in the 'h' struct.
130
//------------------------------------------------------
131
void create_w(){
132

133
  // Create a child process
134
  pid_t f = fork();
135

136
  if(f == 0){ // In the child
137

138
    // Setup signal handlers
139
    // when worker receives SIGUSR1, clean up and exit
140
    signal(SIGUSR1, worker_clean);
141
    // Work until signal is received
142
    printf(" * * * Worker #%d created and beginning to work.\n", getpid());
143
    work();
144

145
  } else if(f > 0){ // In the parent
146

147
    // remember the child's pid for later
148
    h.workers[h.cur_workers] = f;
149
    h.cur_workers++;
150

151
  } else { // fork failed!
152
    // if the fork fails, honestly just give up
153
    // most likely fails due to not having enough resources, so try and cleanly exit
154
    printf("An error has occurred...\n");
155
    printf(" * * * Failed to create a worker...\n");
156
    printf("Program trying to cleanup...\n");
157
    handler_clean(); // maybe will work, maybe not
158

159
  }
160

161
}
162

163
//------------------------------------------------------
164
// remove_w
165
// * Only for use by the handler
166
// PURPOSE: A helper function for 'update_w', removes a single worker
167
//      from the end of the 'workers' array in the 'h' struct.
168
//------------------------------------------------------
169
void remove_w(){
170

171
  // grab pid of worker about to be removed
172
  int pid = h.workers[h.cur_workers - 1];
173

174
  // send signal to last worker, causing it to clean up
175
  kill(h.workers[h.cur_workers - 1], SIGUSR1);
176

177
  // wait for exit of worker
178
  // should be skipped if worker already exited
179
  sleep(1);
180
  waitpid(pid, NULL, 2);
181

182
  // clear pid from list
183
  h.workers[h.cur_workers - 1] = 0;
184
  // decrement cur_workers
185
  h.cur_workers--;
186
  // done
187

188
}
189

190
//------------------------------------------------------
191
// work
192
//
193
// PURPOSE: Keeps a process 'busy', if the process doesn't receive a
194
//      signal, it will be forever stuck in this function.
195
//------------------------------------------------------
196
void work(){
197

198
  while(1){
199
    sleep(1);
200
  }
201

202
}
203

204
void worker_clean(){
205

206
  printf(" * * * Worker #%d clean up and exiting...\n", getpid());
207
  fflush(stdout);
208
  exit(EXIT_SUCCESS);
209

210
}
211

212
void handler_clean(){
213

214
  printf(" Beginning total cleanup.\n");
215
  pid_t pid = h.workers[0];
216
  int status;
217
  // iterate though list of worker pid's, removing them
218
  while(h.cur_workers != 0){
219
    // remove worker
220
    remove_w();
221

222
    // continue loop
223
    // * h.cur_workers is decremented in remove_w, so no need to change loop var
224
  }
225
  // wait for final worker and grab it's status
226
  waitpid(pid, &status, 0);
227

228
  // WIFEXITED takes the status from a wait call, if the status said the process has exited successfully,
229
  // then WIFEXITED will return true, else false
230
  // this is here because sometimes workers won't signal that they're exiting if the handler receives an interrupt signal
231
  // they do it if they need to exit while the handler is still running, but not here
232
  if(WIFEXITED(status)){
233
    printf(" * All workers have exited, handler exiting.\n");
234
    printf("Program completed successfully.\n");
235
    exit(EXIT_SUCCESS);
236
  } else {
237
    printf(" * Not all workers have exited, handler exiting.\n");
238
    exit(EXIT_FAILURE);
239
  }
240

241

242
}
243

244
//-----------------------------------------
245
// Main definition
246
//-----------------------------------------
247

248
//------------------------------------------------------
249
// main
250
//
251
// PURPOSE: Performs initial program setup and handler setup
252
//------------------------------------------------------
253

254
int main(){
255

256
  printf("Program starting...\n");
257
  printf("%d is the handler.\n", getpid());
258
  // Firstly, need to read the config file to know how many workers to create initially
259
  config();
260
  // config calls the update_w function, so workers are created as necessary
261

262
  // this will never be reached by child processes, if it is, something is terribly wrong
263

264
  // set up handler signal listeners
265
  // the handler interrupt signal, clean up all child processes, then exit
266
  signal(SIGINT, handler_clean);
267
  // the signal to re-read config file
268
  signal(SIGHUP, config);
269

270
  printf(" * Initial setup complete!\n");
271
  // keep handler busy, waiting for signals
272
  work();
273

274
  printf("This shouldn't have been reached...\n");
275
  printf("Program trying to cleanup...\n");
276
  handler_clean(); // maybe will work, maybe not
277

278
}

1
//-----------------------------------------
2
// NAME: Ryan Dotzlaw
3
//
4
// REMARKS: Managing threads and communication through shared memory
5
//
6
//-----------------------------------------
7

8
#include <stdio.h>
9
#include <signal.h>
10
#include <string.h>
11
#include <unistd.h>
12
#include <sys/wait.h>
13
#include <stdlib.h>
14
#include <pthread.h>
15

16

17
//-----------------------------------------
18
// Data declarations
19
//-----------------------------------------
20

21
typedef struct THREAD {
22
  pthread_t p;
23
  int signal; // signal = 1: do work, signal = 0: quit
24
  int id; // serves as both an id and index for workers array
25
} thread;
26

27
typedef struct HANDLER {
28
  // The maximum number of workers, or rather, the number of workers to have
29
  int num_workers;
30
  // The current number of workers running (length of workers array)
31
  // If this is different from num_workers, need to add/remove workers
32
  int cur_workers;
33
  // A list of all threads
34
  thread* workers[];
35
} handler;
36

37
// Config filename
38
static char* FILE_NAME = "config.txt";
39

40
// Initialize handler struct
41
handler h;
42

43

44
//-----------------------------------------
45
// Function declarations
46
//-----------------------------------------
47

48
// A function for reading "config.txt"
49
void config();
50
// A function to update the number of workers
51
void update_w();
52
// A function to create a single worker and add it to the end of the workers array
53
void create_w();
54
// A function to remove a single worker from the end of the workers array
55
void remove_w();
56
// A function to keep the workers busy
57
void *work(void* ind);
58
// A function that is called by workers when they're cleaning up and exiting
59
void worker_clean(thread *t);
60
// A function called by the handler when it's time to clean up all workers and shutdown
61
void handler_clean();
62

63
//-----------------------------------------
64
// Function definitions
65
//-----------------------------------------
66

67
//------------------------------------------------------
68
// config
69
// * Only for use by the handler
70
// PURPOSE: Reads the file "config.txt" when called and updates the
71
//      value: 'num_workers' in the 'h' struct.
72
//      Then calls 'update_w'
73
//------------------------------------------------------
74
void config(){
75
  printf(" * Beginning to read config file...\n");
76

77
  int buf;
78

79
  // open config in read only mode
80
  FILE *f = fopen(FILE_NAME, "r");
81

82
  // read in the number of workers
83
  // can be in range [0,9], simply because I don't want to deal w/ converting a string to an int or whatever
84
  buf = fgetc(f) - '0'; // - '0' converts char number to int number
85
  printf(" * New number of workers: %d\n", buf);
86
  h.num_workers = buf;
87

88
  fclose(f);
89
  printf(" * Done reading config file.\n");
90
  update_w();
91
  // Done reading config and updating
92
  // handler can return to whatever it was doing before interrupt
93
}
94

95
//------------------------------------------------------
96
// update_w
97
// * Only for use by the handler
98
// PURPOSE: Uses the handler struct 'h', and it's associated
99
//      values: 'num_workers' and 'cur_workers' to decide
100
//      whether to create/remove workers and how many.
101
//------------------------------------------------------
102
void update_w(){
103

104
  printf(" * * Beginning to update workers\n");
105
  int difference = h.num_workers - h.cur_workers;
106
  // for output
107
  int d = abs(difference);
108
  if(difference == 0){ // No difference, no need for updates
109
    printf(" * * No new workers were created\n");
110
    // Handler goes back to idling
111

112
  } else if(difference > 0){ // difference positive, need to create more workers
113

114
    // create 'difference' more workers
115
    while(difference != 0){
116
      create_w();
117
      difference--;
118
    }
119
    printf(" * * %d new workers were created.\n",d);
120

121
  } else { // difference negative, need to remove workers
122

123
    // remove 'abs(difference)' workers
124
    while(difference != 0){
125
      remove_w();
126
      difference++;
127
    }
128
    printf(" * * %d workers were removed.\n",d);
129

130
  }
131
  // All changes are done, handler will return to config function call
132
}
133
typedef struct X {
134
  int i;
135
} x;
136

137
//------------------------------------------------------
138
// create_w
139
// * Only for use by the handler
140
// PURPOSE: A helper function for 'update_w', creates a single worker
141
//      and appends it to the end of the 'workers' array in the 'h' struct.
142
//------------------------------------------------------
143
void create_w(){
144

145
  // create thread struct
146
  thread *new = malloc(sizeof(thread));
147

148
  // fill in thread struct values
149
  new->id = h.cur_workers;
150
  new->signal = 1;
151

152

153
  printf(" * * * Worker #%d created and beginning to work.\n", new->id);
154
  // update handler
155
  h.workers[h.cur_workers] = new;
156
  h.cur_workers++;
157
  x *index = malloc(sizeof(x));
158
  index->i = new->id;
159
  pthread_create(&new->p, NULL, work, index);
160
  //free(index);
161

162

163
}
164

165
//------------------------------------------------------
166
// remove_w
167
// * Only for use by the handler
168
// PURPOSE: A helper function for 'update_w', removes a single worker
169
//      from the end of the 'workers' array in the 'h' struct.
170
//------------------------------------------------------
171
void remove_w(){
172

173
  thread *temp = h.workers[h.cur_workers - 1];
174
  //printf("%d = cur_workers\n",h.cur_workers);
175
  //printf("in remove_w w/ %d\n", temp->id);
176
  fflush(stdout);
177
  // update the signal value for the last thread
178
  temp->signal = 0;
179
  // wait for thread to rejoin
180
  pthread_join(temp->p, NULL); // no return values
181

182
  // remove temp from workers
183
  //h.workers[h.cur_workers - 1] = NULL;
184

185

186
}
187

188
//------------------------------------------------------
189
// work
190
//
191
// PURPOSE: Keeps a process 'busy', if the thread doesn't receive a
192
//      signal, it will be forever stuck in this function.
193
//------------------------------------------------------
194
void *work(void* ind){
195
  x *st = ind;
196
  int i = st->i;
197
  //printf("index: %d\n", i);
198
  thread *t = h.workers[i];
199
  //printf("%d in work \n", t->id);
200
  while(t->signal){
201
    sleep(1);
202
  }
203
  // t.signal has changed to 0, want to clean up and exit
204
  worker_clean(t);
205
  return NULL;
206
}
207

208
void worker_clean(thread *t){
209

210
  printf(" * * * Worker #%d cleaned up and exiting...\n", t->id);
211
  // update handler
212
  h.cur_workers--;
213
  free(t);
214
  fflush(stdout);
215
  // exit thread, goto join on this thread
216
  pthread_exit(NULL);
217

218
}
219

220
void handler_clean(){
221

222
  printf(" * Beginning total cleanup.\n");
223

224
  // iterate though list of worker threads, removing them
225
  while(h.cur_workers != 0){
226

227
    // remove worker
228
    remove_w();
229

230
    // continue loop
231
    //h.cur_workers--;
232
    // * h.cur_workers is decremented in remove_w, so no need to change loop var
233
  }
234

235
  printf(" * All workers have exited, handler exiting.\n");
236
  printf("Program completed successfully.\n");
237
  exit(EXIT_SUCCESS);
238
}
239

240

241

242
//-----------------------------------------
243
// Main definition
244
//-----------------------------------------
245

246
//------------------------------------------------------
247
// main
248
//
249
// PURPOSE: Performs initial program setup and handler setup
250
//------------------------------------------------------
251

252
int main(){
253

254
  printf("Program starting...\n");
255
  printf("%d is the handler.\n", getpid());
256
  // Firstly, need to read the config file to know how many workers to create initially
257
  config();
258
  // config calls the update_w function, so workers are created as necessary
259

260
  // this will never be reached by child processes, if it is, something is terribly wrong
261

262
  // set up handler signal listeners
263
  // the handler interrupt signal, clean up all child processes, then exit
264
  signal(SIGINT, handler_clean);
265
  // the signal to re-read config file
266
  signal(SIGHUP, config);
267

268
  printf(" * Initial setup complete!\n");
269
  // keep handler busy, waiting for signals
270
  while(1){
271
    sleep(1);
272
  }
273

274
  printf("This shouldn't have been reached...\n");
275
  printf("Program trying to cleanup...\n");
276
  handler_clean(); // maybe will work, maybe not
277

278
}

Threads and Processes Management#

Makefile#

Thread and Process Management#

Code#

Threads and Processes Management #