Use -O not -O3: reduces ccan/tdb test time from 24 to 18 seconds.
[ccan] / ccan / talloc_link / _info
1 #include <stdio.h>
2 #include <string.h>
3 #include "config.h"
4
5 /**
6  * talloc_link - link helper for talloc
7  *
8  * Talloc references can be confusing and buggy.  In the cases where an object
9  * needs multiple parents, all parents need to be aware of the situation; thus
10  * talloc_link is a helper where all "parents" talloc_link an object they
11  * agree to share ownership of.
12  *
13  * Example:
14  *      // Silly program which keeps a cache of uppercased strings.
15  *      // The cache wants to keep strings around even after they may have
16  *      // been "freed" by the caller.
17  *      #include <stdio.h>
18  *      #include <err.h>
19  *      #include <string.h>
20  *      #include <ctype.h>
21  *      #include <ccan/talloc/talloc.h>
22  *      #include <ccan/talloc_link/talloc_link.h>
23  *
24  *      struct upcache {
25  *              const char *str;
26  *              const char *upstr;
27  *      };
28  *
29  *      static struct upcache *cache;
30  *      static unsigned int cache_hits = 0;
31  *      #define CACHE_SIZE 4
32  *      void init_upcase(void)
33  *      {
34  *              cache = talloc_zero_array(NULL, struct upcache, CACHE_SIZE);
35  *      }
36  *
37  *      static struct upcache *lookup_upcase(const char *str)
38  *      {
39  *              unsigned int i;
40  *              for (i = 0; i < CACHE_SIZE; i++)
41  *                      if (cache[i].str && !strcmp(cache[i].str, str)) {
42  *                              cache_hits++;
43  *                              return &cache[i];
44  *                      }
45  *              return NULL;
46  *      }
47  *
48  *      static struct upcache *new_upcase(const char *str)
49  *      {
50  *              unsigned int i;
51  *              char *upstr;
52  *
53  *              upstr = talloc_linked(cache, talloc_strdup(NULL, str));
54  *              if (!upstr)
55  *                      return NULL;
56  *
57  *              i = random() % CACHE_SIZE;
58  *
59  *              // Throw out old: works fine if cache[i].upstr is NULL.
60  *              talloc_delink(cache, cache[i].upstr);
61  *
62  *              // Replace with new.
63  *              cache[i].str = str;
64  *              cache[i].upstr = upstr;
65  *              while (*upstr) {
66  *                      *upstr = toupper(*upstr);
67  *                      upstr++;
68  *              }
69  *              return &cache[i];
70  *      }
71  *
72  *      // If you want to keep the result, talloc_link it.
73  *      const char *get_upcase(const char *str)
74  *      {
75  *              struct upcache *uc = lookup_upcase(str);
76  *              if (!uc)
77  *                      uc = new_upcase(str);
78  *              if (!uc)
79  *                      return NULL;
80  *              return uc->upstr;
81  *      }
82  *
83  *      void exit_upcase(void)
84  *      {
85  *              talloc_free(cache);
86  *              printf("Cache hits: %u\n", cache_hits);
87  *      }
88  *
89  *      int main(int argc, char *argv[])
90  *      {
91  *              unsigned int i;
92  *              const char **values;
93  *
94  *              // Will dump any memory leaks to stderr on exit.
95  *              talloc_enable_leak_report();
96  *
97  *              // Initialize cache.
98  *              init_upcase();
99  *
100  *              // Throw values in.
101  *              values = talloc_array(NULL, const char *, argc);
102  *              for (i = 1; i < argc; i++) {
103  *                      values[i-1] = talloc_link(values, get_upcase(argv[i]));
104  *                      if (!values[i-1])
105  *                              err(1, "Out of memory");
106  *              }
107  *              // This will free all the values, but cache will still work.
108  *              talloc_free(values);
109  *
110  *              // Repeat!
111  *              values = talloc_array(NULL, const char *, argc);
112  *              for (i = 1; i < argc; i++) {
113  *                      values[i-1] = talloc_link(values, get_upcase(argv[i]));
114  *                      if (!values[i-1])
115  *                              err(1, "Out of memory");
116  *              }
117  *
118  *              // This will remove cache links, but we still have a link.
119  *              exit_upcase();
120  *
121  *              // Show values, so we output something.
122  *              for (i = 0; i < argc - 1; i++)
123  *                      printf("%s ", values[i]);
124  *              printf("\n");
125  *
126  *              // This will finally free the upcase strings (last link).
127  *              talloc_free(values);
128  *
129  *              return 0;
130  *      }
131  *
132  * Licence: GPL (2 or any later version)
133  */
134 int main(int argc, char *argv[])
135 {
136         if (argc != 2)
137                 return 1;
138
139         if (strcmp(argv[1], "depends") == 0) {
140                 printf("ccan/talloc\n");
141                 printf("ccan/list\n");
142                 return 0;
143         }
144
145         return 1;
146 }