Mercurial > hg > nginx
comparison src/core/ngx_palloc.c @ 346:55e496a8ece3
nginx-0.0.3-2004-06-06-23:49:18 import
author | Igor Sysoev <igor@sysoev.ru> |
---|---|
date | Sun, 06 Jun 2004 19:49:18 +0000 |
parents | src/core/ngx_alloc.c@ee394e997c77 |
children | f48d579daf78 |
comparison
equal
deleted
inserted
replaced
345:fade4edd61f8 | 346:55e496a8ece3 |
---|---|
1 | |
2 #include <ngx_config.h> | |
3 #include <ngx_core.h> | |
4 | |
5 | |
6 ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log) | |
7 { | |
8 ngx_pool_t *p; | |
9 | |
10 if (!(p = ngx_alloc(size, log))) { | |
11 return NULL; | |
12 } | |
13 | |
14 p->last = (char *) p + sizeof(ngx_pool_t); | |
15 p->end = (char *) p + size; | |
16 p->next = NULL; | |
17 p->large = NULL; | |
18 p->log = log; | |
19 | |
20 return p; | |
21 } | |
22 | |
23 | |
24 void ngx_destroy_pool(ngx_pool_t *pool) | |
25 { | |
26 ngx_pool_t *p, *n; | |
27 ngx_pool_large_t *l; | |
28 | |
29 for (l = pool->large; l; l = l->next) { | |
30 | |
31 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, | |
32 "free: " PTR_FMT, l->alloc); | |
33 | |
34 if (l->alloc) { | |
35 free(l->alloc); | |
36 } | |
37 } | |
38 | |
39 #if (NGX_DEBUG) | |
40 | |
41 /* | |
42 * we could allocate the pool->log from this pool | |
43 * so we can not use this log while the free()ing the pool | |
44 */ | |
45 | |
46 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { | |
47 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, | |
48 "free: " PTR_FMT, p); | |
49 | |
50 if (n == NULL) { | |
51 break; | |
52 } | |
53 } | |
54 | |
55 #endif | |
56 | |
57 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { | |
58 free(p); | |
59 | |
60 if (n == NULL) { | |
61 break; | |
62 } | |
63 } | |
64 } | |
65 | |
66 | |
67 void *ngx_palloc(ngx_pool_t *pool, size_t size) | |
68 { | |
69 char *m; | |
70 ngx_pool_t *p, *n; | |
71 ngx_pool_large_t *large, *last; | |
72 | |
73 if (size <= (size_t) NGX_MAX_ALLOC_FROM_POOL) { | |
74 | |
75 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { | |
76 m = ngx_align(p->last); | |
77 | |
78 if ((size_t) (p->end - m) >= size) { | |
79 p->last = m + size ; | |
80 | |
81 return m; | |
82 } | |
83 | |
84 if (n == NULL) { | |
85 break; | |
86 } | |
87 } | |
88 | |
89 /* alloc a new pool block */ | |
90 | |
91 if (!(n = ngx_create_pool((size_t) (p->end - (char *) p), p->log))) { | |
92 return NULL; | |
93 } | |
94 | |
95 p->next = n; | |
96 m = n->last; | |
97 n->last += size; | |
98 | |
99 return m; | |
100 } | |
101 | |
102 /* alloc a large block */ | |
103 | |
104 large = NULL; | |
105 last = NULL; | |
106 | |
107 if (pool->large) { | |
108 for (last = pool->large; /* void */; last = last->next) { | |
109 if (last->alloc == NULL) { | |
110 large = last; | |
111 last = NULL; | |
112 break; | |
113 } | |
114 | |
115 if (last->next == NULL) { | |
116 break; | |
117 } | |
118 } | |
119 } | |
120 | |
121 if (large == NULL) { | |
122 if (!(large = ngx_palloc(pool, sizeof(ngx_pool_large_t)))) { | |
123 return NULL; | |
124 } | |
125 | |
126 large->next = NULL; | |
127 } | |
128 | |
129 if (!(p = ngx_memalign(ngx_pagesize, size, pool->log))) { | |
130 return NULL; | |
131 } | |
132 | |
133 if (pool->large == NULL) { | |
134 pool->large = large; | |
135 | |
136 } else if (last) { | |
137 last->next = large; | |
138 } | |
139 | |
140 large->alloc = p; | |
141 | |
142 return p; | |
143 } | |
144 | |
145 | |
146 void ngx_pfree(ngx_pool_t *pool, void *p) | |
147 { | |
148 ngx_pool_large_t *l; | |
149 | |
150 for (l = pool->large; l; l = l->next) { | |
151 if (p == l->alloc) { | |
152 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, | |
153 "free: " PTR_FMT, l->alloc); | |
154 free(l->alloc); | |
155 l->alloc = NULL; | |
156 } | |
157 } | |
158 } | |
159 | |
160 | |
161 void *ngx_pcalloc(ngx_pool_t *pool, size_t size) | |
162 { | |
163 void *p; | |
164 | |
165 p = ngx_palloc(pool, size); | |
166 if (p) { | |
167 ngx_memzero(p, size); | |
168 } | |
169 | |
170 return p; | |
171 } | |
172 | |
173 #if 0 | |
174 | |
175 static void *ngx_get_cached_block(size_t size) | |
176 { | |
177 void *p; | |
178 ngx_cached_block_slot_t *slot; | |
179 | |
180 if (ngx_cycle->cache == NULL) { | |
181 return NULL; | |
182 } | |
183 | |
184 slot = &ngx_cycle->cache[(size + ngx_pagesize - 1) / ngx_pagesize]; | |
185 | |
186 slot->tries++; | |
187 | |
188 if (slot->number) { | |
189 p = slot->block; | |
190 slot->block = slot->block->next; | |
191 slot->number--; | |
192 return p; | |
193 } | |
194 | |
195 return NULL; | |
196 } | |
197 | |
198 #endif |