Mercurial > hg > nginx

comparison src/core/ngx_palloc.c @ 2049:2a92804f4109

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*) back out r2040 *) refactor ngx_palloc() *) introduce ngx_pnalloc() *) additional pool blocks have smaller header
author Igor Sysoev <igor@sysoev.ru>
date Tue, 17 Jun 2008 15:00:30 +0000
parents 4d8140271204
children cca975b532bf
comparison
equal deleted inserted replaced
2048:824615f3b4ec 2049:2a92804f4109
6 6
7 #include <ngx_config.h> 7 #include <ngx_config.h>
8 #include <ngx_core.h> 8 #include <ngx_core.h>
9 9
10 10
11 static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
12 static void *ngx_palloc_large(ngx_pool_t *pool, size_t size);
13
14
11 ngx_pool_t * 15 ngx_pool_t *
12 ngx_create_pool(size_t size, ngx_log_t *log) 16 ngx_create_pool(size_t size, ngx_log_t *log)
13 { 17 {
14 ngx_pool_t *p; 18 ngx_pool_t *p;
15 19
16 p = ngx_alloc(size, log); 20 p = ngx_alloc(size, log);
17 if (p == NULL) { 21 if (p == NULL) {
18 return NULL; 22 return NULL;
19 } 23 }
20 24
21 p->last = (u_char *) p + sizeof(ngx_pool_t); 25 p->d.last = (u_char *) p + sizeof(ngx_pool_t);
22 p->end = (u_char *) p + size; 26 p->d.end = (u_char *) p + size;
27 p->d.next = NULL;
28
29 p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size - sizeof(ngx_pool_t):
30 NGX_MAX_ALLOC_FROM_POOL;
23 p->current = p; 31 p->current = p;
24 p->chain = NULL; 32 p->chain = NULL;
25 p->next = NULL;
26 p->large = NULL; 33 p->large = NULL;
27 p->cleanup = NULL; 34 p->cleanup = NULL;
28 p->log = log; 35 p->log = log;
29 36
30 return p; 37 return p;
60 /* 67 /*
61 * we could allocate the pool->log from this pool 68 * we could allocate the pool->log from this pool
62 * so we can not use this log while the free()ing the pool 69 * so we can not use this log while the free()ing the pool
63 */ 70 */
64 71
65 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { 72 for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
66 ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0, 73 ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
67 "free: %p, unused: %uz", p, p->end - p->last); 74 "free: %p, unused: %uz", p, p->d.end - p->d.last);
68 75
69 if (n == NULL) { 76 if (n == NULL) {
70 break; 77 break;
71 } 78 }
72 } 79 }
73 80
74 #endif 81 #endif
75 82
76 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { 83 for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
77 ngx_free(p); 84 ngx_free(p);
78 85
79 if (n == NULL) { 86 if (n == NULL) {
80 break; 87 break;
81 } 88 }
84 91
85 92
86 void * 93 void *
87 ngx_palloc(ngx_pool_t *pool, size_t size) 94 ngx_palloc(ngx_pool_t *pool, size_t size)
88 { 95 {
89 u_char *m; 96 u_char *m;
90 ngx_pool_t *p, *n, *current; 97 ngx_pool_t *p;
91 ngx_pool_large_t *large; 98
92 99 if (size <= pool->max) {
93 if (size <= (size_t) NGX_MAX_ALLOC_FROM_POOL 100
94 && size <= (size_t) (pool->end - (u_char *) pool)
95 - (size_t) ngx_align_ptr(sizeof(ngx_pool_t), NGX_ALIGNMENT))
96 {
97 p = pool->current; 101 p = pool->current;
98 current = p; 102
99 103 do {
100 for ( ;; ) { 104 m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);
101 105
102 /* 106 if ((size_t) (p->d.end - m) >= size) {
103 * allow non-aligned memory blocks for small allocations (1, 2, 107 p->d.last = m + size;
104 * or 3 bytes) and for odd length strings (struct's have aligned
105 * size)
106 */
107
108 if (size < sizeof(int) || (size & 1)) {
109 m = p->last;
110
111 } else {
112 m = ngx_align_ptr(p->last, NGX_ALIGNMENT);
113 }
114
115 if ((size_t) (p->end - m) >= size) {
116 p->last = m + size;
117 108
118 return m; 109 return m;
119 } 110 }
120 111
121 if ((size_t) (p->end - m) < NGX_ALIGNMENT) { 112 p = p->d.next;
122 current = p->next; 113
114 } while (p);
115
116 return ngx_palloc_block(pool, size);
117 }
118
119 return ngx_palloc_large(pool, size);
120 }
121
122
123 void *
124 ngx_pnalloc(ngx_pool_t *pool, size_t size)
125 {
126 u_char *m;
127 ngx_pool_t *p;
128
129 if (size <= pool->max) {
130
131 p = pool->current;
132
133 do {
134 m = p->d.last;
135
136 if ((size_t) (p->d.end - m) >= size) {
137 p->d.last = m + size;
138
139 return m;
123 } 140 }
124 141
125 if (p->next == NULL) { 142 p = p->d.next;
126 break; 143
127 } 144 } while (p);
128 145
129 p = p->next; 146 return ngx_palloc_block(pool, size);
130 pool->current = current; 147 }
131 } 148
132 149 return ngx_palloc_large(pool, size);
133 /* allocate a new pool block */ 150 }
134 151
135 n = ngx_create_pool((size_t) (p->end - (u_char *) p), p->log); 152
136 if (n == NULL) { 153 static void *
137 return NULL; 154 ngx_palloc_block(ngx_pool_t *pool, size_t size)
138 } 155 {
139 156 u_char *m;
140 pool->current = current ? current : n; 157 ngx_pool_t *p, *new, *current;
141 158
142 p->next = n; 159 new = ngx_create_pool((size_t) (pool->d.end - (u_char *) pool), pool->log);
143 m = ngx_align_ptr(n->last, NGX_ALIGNMENT); 160 if (new == NULL) {
144 n->last = m + size; 161 return NULL;
145 162 }
146 return m; 163
147 } 164 current = pool->current;
165
166 for (p = current; p->d.next; p = p->d.next) {
167 if ((size_t) (p->d.end - p->d.last) < NGX_ALIGNMENT) {
168 current = p->d.next;
169 }
170 }
171
172 p->d.next = new;
173
174 pool->current = current ? current : new;
175
176 m = (u_char *) new + sizeof(ngx_pool_data_t);
177 new->d.last = m + size;
178
179 return m;
180 }
181
182
183 static void *
184 ngx_palloc_large(ngx_pool_t *pool, size_t size)
185 {
186 void *p;
187 ngx_pool_large_t *large;
148 188
149 #if 0 189 #if 0
150 p = ngx_memalign(ngx_pagesize, size, pool->log); 190 p = ngx_memalign(ngx_pagesize, size, pool->log);
151 if (p == NULL) { 191 if (p == NULL) {
152 return NULL; 192 return NULL;
167 large->alloc = p; 207 large->alloc = p;
168 large->next = pool->large; 208 large->next = pool->large;
169 pool->large = large; 209 pool->large = large;
170 210
171 return p; 211 return p;
172 }
173
174
175 void *
176 ngx_palloc_aligned(ngx_pool_t *pool, size_t size)
177 {
178 if (size & 1) {
179 size++;
180 }
181
182 return ngx_palloc(pool, size);
183 } 212 }
184 213
185 214
186 ngx_int_t 215 ngx_int_t
187 ngx_pfree(ngx_pool_t *pool, void *p) 216 ngx_pfree(ngx_pool_t *pool, void *p)