antithread, failtest: use ccan/err instead of err.h.
[ccan] / ccan / antithread / _info
1 #include <stdio.h>
2 #include <string.h>
3 #include "config.h"
4
5 /**
6  * antithread - Accelerated Native Technology Implementation of "threads"
7  *
8  * On systems with multiple CPUs, it's often faster to split work across
9  * different execution units.  Under Unix-like systems, the two methods of
10  * doing this are (POSIX) threads or processes.
11  *
12  * Threads have the disadvantage that they share all of the address space:
13  * using software instead of hardware isolation (eg. for malloc) is
14  * inefficient and less secure.  Various subtle errors can occur because
15  * programmers in one part of the code do not expect concurrency.
16  *
17  * Processes have the disadvantage that there is no common infrastructure
18  * for sharing memory: without this, programmers are faced with the unpalatable
19  * options of using slower options or creating their own infrastructure.
20  *
21  * The antithread module provides memory-sharing infrastructure: the programmer
22  * indicates the size of the memory to share, and then creates subprocesses
23  * which share the memory.  Pipes are used to hand pointers between the
24  * main process and the children: usually pointers into the shared memory.
25  *
26  * Example:
27  *      #include <ccan/antithread/antithread.h>
28  *      #include <ccan/talloc/talloc.h>
29  *      #include <ctype.h>
30  *      #include <stdlib.h>
31  *      #include <stdio.h>
32  *      #include <string.h>
33  *      
34  *      // Silly example: child makes rot13 copy.
35  *      static void *rot13(struct at_pool *pool, void *unused)
36  *      {
37  *              char *r, *p;
38  *              while ((r = at_read_parent(pool)) != NULL) {
39  *                      unsigned int i;
40  *                      // r is inside pool, so talloc off it is also inside.
41  *                      p = talloc_array(r, char, strlen(r) + 1);
42  *                      for (i = 0; r[i]; i++) {
43  *                              if (!isalpha(r[i]))
44  *                                      p[i] = r[i];
45  *                              else if (toupper(r[i]) < 'N')
46  *                                      p[i] = r[i] + 13;
47  *                              else
48  *                                      p[i] = r[i] - 13;
49  *                      }
50  *                      // Tell parent about our copy.
51  *                      at_tell_parent(pool, p);
52  *              }
53  *              return NULL;
54  *      }
55  *      
56  *      #define NUM_CHILDREN 4
57  *      
58  *      int main(int argc, char *argv[])
59  *      {
60  *              struct at_pool *pool;
61  *              struct athread *child[NUM_CHILDREN];
62  *              unsigned int i;
63  *      
64  *              // Create pool and some children
65  *              pool = at_pool(1024*1024);
66  *              for (i = 0; i < NUM_CHILDREN; i++)
67  *                      child[i] = at_run(pool, rot13, NULL);
68  *      
69  *              // Pass out work to children.
70  *              for (i = 1; i < argc; i++)
71  *                      at_tell(child[i % NUM_CHILDREN],
72  *                              talloc_strdup(at_pool_ctx(pool), argv[i]));
73  *      
74  *              // Read back results.
75  *              for (i = 1; i < argc; i++)
76  *                      printf("%s ", (char *)at_read(child[i % NUM_CHILDREN]));
77  *              printf("\n");
78  *      
79  *              // Freeing pool kills children, too.
80  *              talloc_free(pool);
81  *              return 0;
82  *      }
83  *
84  * License: GPL (v3 or any later version)
85  * Author: Rusty Russell <rusty@rustcorp.com.au>
86  */
87 int main(int argc, char *argv[])
88 {
89         if (argc != 2)
90                 return 1;
91
92         if (strcmp(argv[1], "depends") == 0) {
93                 printf("ccan/alloc\n");
94                 printf("ccan/err\n");
95                 printf("ccan/list\n");
96                 printf("ccan/noerr\n");
97                 printf("ccan/read_write_all\n"); /* For tests */
98                 printf("ccan/talloc\n");
99                 return 0;
100         }
101
102         return 1;
103 }