Mercurial > hg > nginx

comparison src/core/ngx_palloc.c @ 346:55e496a8ece3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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