Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
2afe3367819dbe68bef7646a66af1fa18d1e681a
[simgrid.git] / examples / xbt / sem_sched.c
1 #include <stdio.h>\r
2 #include <stdlib.h>\r
3 #include <string.h>\r
4 #include <errno.h>\r
5 \r
6 \r
7 #include "xbt/xbt_os_thread.h"\r
8 #include "xbt.h"\r
9 #include "xbt/log.h"\r
10 XBT_LOG_NEW_DEFAULT_CATEGORY(sem_sched,"Messages specific for this sem example");\r
11 \r
12 #ifndef ENOBUFS\r
13 #define ENOBUFS         1024\r
14 #endif\r
15 \r
16 #define CTX_MAX                 ((unsigned int)1000)\r
17 \r
18 \r
19 #define MAX_ARG                                         30\r
20 #define MAX_ARGS                                        10\r
21 \r
22 typedef int (*pfn_func_t)(int, char**);\r
23 \r
24 static int\r
25 __next_ctx_ID = 0;\r
26 \r
27 typedef struct s_job\r
28 {\r
29         pfn_func_t func;\r
30         int argc;\r
31         char** argv;\r
32 }s_job_t,* job_t;\r
33 \r
34 \r
35 job_t\r
36 job_new(pfn_func_t func, int argc, char** argv);\r
37 \r
38 int\r
39 job_execute(job_t job);\r
40 \r
41 int\r
42 job_free(job_t* ref);\r
43 \r
44 /* an entry of the table of threads */\r
45 typedef struct s_ctx\r
46 {\r
47         xbt_os_sem_t begin;\r
48         xbt_os_sem_t end;\r
49         int failure;\r
50         job_t job;\r
51         xbt_os_thread_t imp;\r
52         int index;\r
53 }s_ctx_t,* ctx_t;\r
54 \r
55 typedef struct s_shed\r
56 {\r
57         ctx_t* ctxs;\r
58         int size;\r
59         int capacity;\r
60 }s_sched_t,* sched_t;\r
61 \r
62 \r
63 void \r
64 schedule(ctx_t c);\r
65 void \r
66 unschedule(ctx_t c);\r
67 \r
68 void*\r
69 ctx_function(void* param);\r
70 \r
71 ctx_t \r
72 ctx_new(job_t job);\r
73 \r
74 int \r
75 ctx_free(ctx_t* ref);\r
76 \r
77 sched_t\r
78 sched_new(int size);\r
79 \r
80 int\r
81 sched_add_job(sched_t sched, job_t job);\r
82 \r
83 int\r
84 sched_init(sched_t sched);\r
85 \r
86 int\r
87 sched_schedule(sched_t sched);\r
88 \r
89 int\r
90 sched_clean(sched_t sched);\r
91 \r
92 int\r
93 sched_free(sched_t* ref);\r
94 \r
95 int\r
96 job(int argc, char* argv[]);\r
97 \r
98 int\r
99 main(int argc, char* argv[])\r
100 {\r
101         sched_t sched;\r
102         int i, size;\r
103         char** __argv;\r
104         char arg[MAX_ARG] = {0};\r
105         \r
106         \r
107         xbt_init(&argc, argv);\r
108         \r
109         if(argc != 2) \r
110         {\r
111                 INFO1("Usage: %s job count",argv[0]);\r
112                 exit(EXIT_FAILURE);\r
113         }  \r
114         \r
115         \r
116         size = atoi(argv[1]);\r
117         \r
118         /* create a new scheduler */\r
119         sched = sched_new(size);\r
120         \r
121         if(!sched)\r
122         {\r
123                 INFO1("sched_new() failed : errno %d",errno);\r
124                 xbt_exit();\r
125                 exit(EXIT_FAILURE);\r
126         }\r
127         \r
128         __argv = (char**)calloc(MAX_ARGS,sizeof(char*));\r
129         \r
130         for(i = 0; i < MAX_ARGS; i++)\r
131         {\r
132                 sprintf(arg,"arg_%d",i);\r
133                 __argv[i] = strdup(arg);\r
134                 memset(arg,0,MAX_ARG);\r
135                 \r
136         }\r
137         \r
138         for(i = 0; i < size; i++)\r
139                 sched_add_job(sched,job_new(job,(i < MAX_ARGS) ? i : MAX_ARGS,__argv));\r
140         \r
141         /* initialize the scheduler */\r
142         if(sched_init(sched) < 0)\r
143         {\r
144                 sched_free(&sched);\r
145                 INFO1("sched_init() failed : errno %d\n",errno);\r
146                 xbt_exit();\r
147                 exit(EXIT_FAILURE);\r
148         }\r
149         \r
150         /* schedule the jobs */\r
151         if(sched_schedule(sched) < 0)\r
152         {\r
153                 sched_free(&sched);\r
154                 INFO1("sched_init() failed : errno %d",errno);\r
155                 xbt_exit();\r
156                 exit(EXIT_FAILURE);\r
157         }\r
158         \r
159         /* cleanup */\r
160         if(sched_clean(sched) < 0)\r
161         {\r
162                 sched_free(&sched);\r
163                 INFO1("sched_init() failed : errno %d",errno);\r
164                 xbt_exit();\r
165                 exit(EXIT_FAILURE);\r
166         }\r
167         \r
168         /* destroy the scheduler */\r
169         sched_free(&sched);\r
170         \r
171         INFO1("sem_sched terminated with exit code %d (success)",EXIT_SUCCESS);\r
172 \r
173         xbt_exit();\r
174         \r
175         return EXIT_SUCCESS;\r
176                 \r
177 }\r
178 \r
179 void*\r
180 ctx_function(void* param)\r
181 {\r
182         int i = 0;\r
183         int exit_code = 1;\r
184         ctx_t ctx = (ctx_t)param;\r
185         \r
186         INFO1("Hello i'm the owner of the context %d, i'm waiting for starting",ctx->index);\r
187         \r
188         unschedule(ctx);\r
189         \r
190         if(ctx->failure)\r
191         {\r
192                 INFO1("0ups the scheduler initialization failed bye {%d}.",ctx->index);\r
193                 xbt_os_thread_exit(&exit_code);\r
194         }\r
195         \r
196         INFO1("I'm the owner of the context %d : I'm started",ctx->index);\r
197         INFO0("Wait a minute, I do my job");\r
198         \r
199         /* do its job */\r
200         exit_code = job_execute(ctx->job);\r
201         \r
202         INFO1("Have finished my job, bye {%d}\n",ctx->index);\r
203         \r
204         xbt_os_sem_release(ctx->end);\r
205         \r
206         xbt_os_thread_exit(&exit_code);\r
207 }\r
208 \r
209 void schedule(ctx_t c) \r
210 {\r
211         xbt_os_sem_release(c->begin);   /* allow C to go                */\r
212         xbt_os_sem_acquire(c->end);     /* wait C's end                 */\r
213 }\r
214 \r
215 void unschedule(ctx_t c) \r
216 {\r
217    xbt_os_sem_release(c->end);          /* I'm done, dude               */\r
218    xbt_os_sem_acquire(c->begin);        /* can I start again?   */\r
219 }\r
220 \r
221 ctx_t \r
222 ctx_new(job_t job)\r
223 {\r
224         ctx_t ctx = (ctx_t)calloc(1,sizeof(s_ctx_t));\r
225         ctx->index = ++__next_ctx_ID;\r
226         ctx->begin = xbt_os_sem_init(0);\r
227         ctx->end = xbt_os_sem_init(0);\r
228         ctx->failure = 0;\r
229         ctx->job = job;\r
230         \r
231         return ctx;\r
232 }\r
233 \r
234 int \r
235 ctx_free(ctx_t* ref)\r
236 {\r
237         ctx_t ctx;\r
238         if(!(*ref))\r
239                 return EINVAL;\r
240         \r
241         ctx = *ref;\r
242         \r
243         xbt_os_sem_destroy(ctx->begin);\r
244         xbt_os_sem_destroy(ctx->end);\r
245         job_free(&(ctx->job));\r
246         free(ctx);\r
247         *ref = NULL;\r
248         \r
249         return 0;\r
250 }\r
251 \r
252 sched_t\r
253 sched_new(int size)\r
254 {\r
255         sched_t sched;\r
256         \r
257         if(size <= 0)\r
258         {\r
259                 errno = EINVAL;\r
260                 return NULL;\r
261         }\r
262         \r
263         sched = (sched_t)calloc(1,sizeof(s_sched_t));\r
264         \r
265         if(!sched)\r
266         {\r
267                 errno = ENOMEM;\r
268                 return NULL;\r
269         }\r
270                 \r
271         sched->ctxs = (ctx_t*)calloc(size,sizeof(ctx_t));\r
272         \r
273         if(!(sched->ctxs))\r
274         {\r
275                 errno = ENOMEM;\r
276                 free(sched);\r
277                 return NULL;\r
278         }\r
279         \r
280         sched->size = 0;\r
281         sched->capacity = size;\r
282         \r
283         return sched;\r
284 }\r
285 \r
286 int\r
287 sched_add_job(sched_t sched, job_t job)\r
288 {\r
289         if(!sched || !job)\r
290                 return EINVAL;\r
291         \r
292         if(sched->capacity < sched->size)\r
293                 return ENOBUFS;\r
294                 \r
295         sched->ctxs[(sched->size)++] = ctx_new(job);\r
296         \r
297         return 0;\r
298 }\r
299 \r
300 int\r
301 sched_init(sched_t sched)\r
302 {\r
303         int i,j;\r
304         int success = 1;\r
305         \r
306         if(!sched)\r
307                 return EINVAL;\r
308         \r
309         for(i = 0; i < sched->size; i++)\r
310         {       \r
311                 sched->ctxs[i]->imp = xbt_os_thread_create("thread",ctx_function,(void*)sched->ctxs[i]);\r
312                 \r
313                 xbt_os_sem_acquire(sched->ctxs[i]->end);\r
314         }\r
315         \r
316         if(!success)\r
317         {\r
318                 for(j = 0; j < i; j++)\r
319                 {\r
320                         sched->ctxs[j]->failure = 1;\r
321                         xbt_os_sem_release(sched->ctxs[j]->begin);\r
322                 }\r
323                         \r
324                 for(j = 0; j < i; j++)\r
325                 {\r
326                         xbt_os_thread_join(sched->ctxs[j]->imp,0);\r
327                         \r
328                         ctx_free(&(sched->ctxs[j]));\r
329                 }\r
330                 \r
331                 return -1;\r
332                                         \r
333         }\r
334         \r
335         return 0;\r
336 }\r
337 \r
338 int\r
339 sched_schedule(sched_t sched)\r
340 {\r
341         int i;\r
342         \r
343         if(!sched)\r
344                 return EINVAL;\r
345                 \r
346         for(i = 0; i < sched->size; i++)\r
347                 schedule(sched->ctxs[i]);\r
348                 \r
349         return 0;\r
350 }\r
351 \r
352 int\r
353 sched_clean(sched_t sched)\r
354 {\r
355         int i;\r
356         \r
357         if(!sched)\r
358                 return EINVAL;\r
359                 \r
360         for(i = 0; i < sched->size; i++)\r
361         {\r
362                 xbt_os_thread_join(sched->ctxs[i]->imp,NULL);\r
363                 \r
364                 ctx_free(&(sched->ctxs[i]));\r
365         }\r
366         \r
367         return 0;\r
368 }\r
369 \r
370 int\r
371 sched_free(sched_t* ref)\r
372 {\r
373         if(*ref)\r
374                 return EINVAL;\r
375                 \r
376         free(((sched_t)(*ref))->ctxs);\r
377         \r
378         *ref = NULL;\r
379         \r
380         return 0;\r
381 }\r
382 \r
383 \r
384 int\r
385 job(int argc, char** argv)\r
386 {\r
387         int i = 0;\r
388         \r
389         INFO0("I'm the job : I'm going to print all the args of my commande line");\r
390         \r
391         INFO1("-- Arguments (%d):",argc);\r
392         \r
393         for(i = 0; i < argc; i++)\r
394                 INFO2("  ---- [%i] %s",i,argv[i]);\r
395                 \r
396         return 0;\r
397 }\r
398 \r
399 job_t\r
400 job_new(pfn_func_t func, int argc, char** argv)\r
401 {\r
402         job_t job;\r
403         int i;\r
404         \r
405         /* todo check the parameters */\r
406         job = (job_t)calloc(1,sizeof(s_job_t));\r
407         \r
408         if(!job)\r
409         {\r
410                 errno = ENOMEM;\r
411                 return NULL;\r
412         }\r
413         \r
414         job->argv = (char**)calloc(argc,sizeof(char*));\r
415         \r
416         if(!(job->argv))\r
417         {\r
418                 free(job);\r
419                 errno = ENOMEM;\r
420                 return NULL;\r
421         }\r
422         \r
423         for(i = 0; i < argc; i++)\r
424                 job->argv[i] = strdup(argv[i]);\r
425         \r
426         job->func = func;       \r
427         job->argc = argc;\r
428         \r
429         return job;\r
430 }\r
431 \r
432 int\r
433 job_execute(job_t job)\r
434 {\r
435         if(!job)\r
436                 return EINVAL;\r
437                 \r
438         return (*(job->func))(job->argc, job->argv);\r
439 }\r
440 \r
441 int\r
442 job_free(job_t* ref)\r
443 {\r
444         job_t job;\r
445         int i;\r
446         \r
447         if(!(*ref))\r
448                 return EINVAL;\r
449                 \r
450         job = *ref;\r
451         \r
452         for(i = 0; i < job->argc; i++)\r
453                 free(job->argv[i]);\r
454         \r
455         free(job->argv);\r
456         free(*ref);\r
457         *ref = NULL;\r
458         \r
459         return 0;\r
460 }\r
461 \r
462 \r
463 \r