1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 #define _BSD_SOURCE /* sys/mman.h: MAP_ANON */
25 #include "alloc_arena.h"
26
27 #include "alloc_impl.h"
28 #include "internal/once.h"
29 #include "sal/macros.h"
30 #include "osl/diagnose.h"
31
32 #include <string.h>
33 #include <stdio.h>
34
35 #ifdef OS2
36 #undef OSL_TRACE
37 #define OSL_TRACE 1 ? ((void)0) : _OSL_GLOBAL osl_trace
38 #define INCL_DOS
39 #include <os2.h>
40 #endif
41
42 /* ================================================================= *
43 *
44 * arena internals.
45 *
46 * ================================================================= */
47
48 /** g_arena_list
49 * @internal
50 */
51 struct rtl_arena_list_st
52 {
53 rtl_memory_lock_type m_lock;
54 rtl_arena_type m_arena_head;
55 };
56
57 static struct rtl_arena_list_st g_arena_list;
58
59
60 /** gp_arena_arena
61 * provided for arena_type allocations, and hash_table resizing.
62 *
63 * @internal
64 */
65 static rtl_arena_type * gp_arena_arena = NULL;
66
67
68 /** gp_machdep_arena
69 *
70 * Low level virtual memory (pseudo) arena
71 * (platform dependent implementation)
72 *
73 * @internal
74 */
75 static rtl_arena_type * gp_machdep_arena = NULL;
76
77
78 static void *
79 SAL_CALL rtl_machdep_alloc (
80 rtl_arena_type * pArena,
81 sal_Size * pSize
82 );
83
84 static void
85 SAL_CALL rtl_machdep_free (
86 rtl_arena_type * pArena,
87 void * pAddr,
88 sal_Size nSize
89 );
90
91 static sal_Size
92 rtl_machdep_pagesize (void);
93
94
95 /** gp_default_arena
96 */
97 rtl_arena_type * gp_default_arena = NULL;
98
99
100 /** rtl_arena_init()
101 * @internal
102 */
103 static int
104 rtl_arena_init (void);
105
106
107 /* ================================================================= */
108
109 /** rtl_arena_segment_constructor()
110 */
111 static int
rtl_arena_segment_constructor(void * obj)112 rtl_arena_segment_constructor (void * obj)
113 {
114 rtl_arena_segment_type * segment = (rtl_arena_segment_type*)(obj);
115
116 QUEUE_START_NAMED(segment, s);
117 QUEUE_START_NAMED(segment, f);
118
119 return (1);
120 }
121
122
123 /** rtl_arena_segment_destructor()
124 */
125 static void
rtl_arena_segment_destructor(void * obj)126 rtl_arena_segment_destructor (void * obj)
127 {
128 #if OSL_DEBUG_LEVEL == 0
129 (void) obj; /* unused */
130 #else /* OSL_DEBUG_LEVEL */
131 rtl_arena_segment_type * segment = (rtl_arena_segment_type*)(obj);
132
133 OSL_ASSERT(QUEUE_STARTED_NAMED(segment, s));
134 OSL_ASSERT(QUEUE_STARTED_NAMED(segment, f));
135 #endif /* OSL_DEBUG_LEVEL */
136 }
137
138 /* ================================================================= */
139
140 /** rtl_arena_segment_populate()
141 *
142 * @precond arena->m_lock acquired.
143 */
144 static int
rtl_arena_segment_populate(rtl_arena_type * arena)145 rtl_arena_segment_populate (
146 rtl_arena_type * arena
147 )
148 {
149 rtl_arena_segment_type *span;
150 sal_Size size = rtl_machdep_pagesize();
151
152 span = rtl_machdep_alloc(gp_machdep_arena, &size);
153 if (span != NULL)
154 {
155 rtl_arena_segment_type *first, *last, *head;
156 sal_Size count = size / sizeof(rtl_arena_segment_type);
157
158 /* insert onto reserve span list */
159 QUEUE_INSERT_TAIL_NAMED(&(arena->m_segment_reserve_span_head), span, s);
160 QUEUE_START_NAMED(span, f);
161 span->m_addr = (sal_uIntPtr)(span);
162 span->m_size = size;
163 span->m_type = RTL_ARENA_SEGMENT_TYPE_SPAN;
164
165 /* insert onto reserve list */
166 head = &(arena->m_segment_reserve_head);
167 for (first = span + 1, last = span + count; first < last; ++first)
168 {
169 QUEUE_INSERT_TAIL_NAMED(head, first, s);
170 QUEUE_START_NAMED(first, f);
171 first->m_addr = 0;
172 first->m_size = 0;
173 first->m_type = 0;
174 }
175 }
176 return (span != NULL);
177 }
178
179
180 /** rtl_arena_segment_get()
181 *
182 * @precond arena->m_lock acquired.
183 * @precond (*ppSegment == 0)
184 */
185 static RTL_MEMORY_INLINE void
rtl_arena_segment_get(rtl_arena_type * arena,rtl_arena_segment_type ** ppSegment)186 rtl_arena_segment_get (
187 rtl_arena_type * arena,
188 rtl_arena_segment_type ** ppSegment
189 )
190 {
191 rtl_arena_segment_type * head;
192
193 OSL_ASSERT(*ppSegment == NULL);
194
195 head = &(arena->m_segment_reserve_head);
196 if ((head->m_snext != head) || rtl_arena_segment_populate (arena))
197 {
198 (*ppSegment) = head->m_snext;
199 QUEUE_REMOVE_NAMED((*ppSegment), s);
200 }
201 }
202
203 #if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
204 #pragma inline(rtl_arena_segment_get)
205 #endif
206
207
208 /** rtl_arena_segment_put()
209 *
210 * @precond arena->m_lock acquired.
211 * @postcond (*ppSegment == 0)
212 */
213 static RTL_MEMORY_INLINE void
rtl_arena_segment_put(rtl_arena_type * arena,rtl_arena_segment_type ** ppSegment)214 rtl_arena_segment_put (
215 rtl_arena_type * arena,
216 rtl_arena_segment_type ** ppSegment
217 )
218 {
219 rtl_arena_segment_type * head;
220
221 OSL_ASSERT(QUEUE_STARTED_NAMED((*ppSegment), s));
222 OSL_ASSERT(QUEUE_STARTED_NAMED((*ppSegment), f));
223
224 (*ppSegment)->m_addr = 0;
225 (*ppSegment)->m_size = 0;
226
227 OSL_ASSERT((*ppSegment)->m_type != RTL_ARENA_SEGMENT_TYPE_HEAD);
228 (*ppSegment)->m_type = 0;
229
230 /* keep as reserve */
231 head = &(arena->m_segment_reserve_head);
232 QUEUE_INSERT_HEAD_NAMED(head, (*ppSegment), s);
233
234 /* clear */
235 (*ppSegment) = NULL;
236 }
237
238 #if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
239 #pragma inline(rtl_arena_segment_put)
240 #endif
241
242 /* ================================================================= */
243
244 /** rtl_arena_freelist_insert()
245 *
246 * @precond arena->m_lock acquired.
247 */
248 static RTL_MEMORY_INLINE void
rtl_arena_freelist_insert(rtl_arena_type * arena,rtl_arena_segment_type * segment)249 rtl_arena_freelist_insert (
250 rtl_arena_type * arena,
251 rtl_arena_segment_type * segment
252 )
253 {
254 rtl_arena_segment_type * head;
255
256 head = &(arena->m_freelist_head[highbit(segment->m_size) - 1]);
257 QUEUE_INSERT_TAIL_NAMED(head, segment, f);
258
259 arena->m_freelist_bitmap |= head->m_size;
260 }
261
262 #if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
263 #pragma inline(rtl_arena_freelist_insert)
264 #endif /* __SUNPRO_C */
265
266
267 /** rtl_arena_freelist_remove()
268 *
269 * @precond arena->m_lock acquired.
270 */
271 static RTL_MEMORY_INLINE void
rtl_arena_freelist_remove(rtl_arena_type * arena,rtl_arena_segment_type * segment)272 rtl_arena_freelist_remove (
273 rtl_arena_type * arena,
274 rtl_arena_segment_type * segment
275 )
276 {
277 if ((segment->m_fnext->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD) &&
278 (segment->m_fprev->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD) )
279 {
280 rtl_arena_segment_type * head;
281
282 head = segment->m_fprev;
283 OSL_ASSERT(arena->m_freelist_bitmap & head->m_size);
284 arena->m_freelist_bitmap ^= head->m_size;
285 }
286 QUEUE_REMOVE_NAMED(segment, f);
287 }
288
289 #if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
290 #pragma inline(rtl_arena_freelist_remove)
291 #endif /* __SUNPRO_C */
292
293
294 /* ================================================================= */
295
296 /** RTL_ARENA_HASH_INDEX()
297 */
298 #define RTL_ARENA_HASH_INDEX_IMPL(a, s, q, m) \
299 ((((a) + ((a) >> (s)) + ((a) >> ((s) << 1))) >> (q)) & (m))
300
301 #define RTL_ARENA_HASH_INDEX(arena, addr) \
302 RTL_ARENA_HASH_INDEX_IMPL((addr), (arena)->m_hash_shift, (arena)->m_quantum_shift, ((arena)->m_hash_size - 1))
303
304 /** rtl_arena_hash_rescale()
305 *
306 * @precond arena->m_lock released.
307 */
308 static void
rtl_arena_hash_rescale(rtl_arena_type * arena,sal_Size new_size)309 rtl_arena_hash_rescale (
310 rtl_arena_type * arena,
311 sal_Size new_size
312 )
313 {
314 rtl_arena_segment_type ** new_table;
315 sal_Size new_bytes;
316
317 new_bytes = new_size * sizeof(rtl_arena_segment_type*);
318 new_table = (rtl_arena_segment_type **)rtl_arena_alloc (gp_arena_arena, &new_bytes);
319
320 if (new_table != NULL)
321 {
322 rtl_arena_segment_type ** old_table;
323 sal_Size old_size, i;
324
325 memset (new_table, 0, new_bytes);
326
327 RTL_MEMORY_LOCK_ACQUIRE(&(arena->m_lock));
328
329 old_table = arena->m_hash_table;
330 old_size = arena->m_hash_size;
331
332 OSL_TRACE(
333 "rtl_arena_hash_rescale(\"%s\"): "
334 "nseg: %"PRIu64" (ave: %"PRIu64"), frees: %"PRIu64" "
335 "[old_size: %lu, new_size: %lu]",
336 arena->m_name,
337 arena->m_stats.m_alloc - arena->m_stats.m_free,
338 (arena->m_stats.m_alloc - arena->m_stats.m_free) >> arena->m_hash_shift,
339 arena->m_stats.m_free,
340 old_size, new_size
341 );
342
343 #if 0 /* DBG */
344 for (i = 0; i < arena->m_hash_size; i++)
345 {
346 sal_Size k = 0; rtl_arena_segment_type ** segpp = &(arena->m_hash_table[i]);
347 while (*segpp)
348 {
349 k += 1;
350 segpp = &((*segpp)->m_fnext);
351 }
352 fprintf(stdout, "%d, ", k);
353 }
354 fprintf(stdout, "\n");
355 #endif /* DBG */
356
357 arena->m_hash_table = new_table;
358 arena->m_hash_size = new_size;
359 arena->m_hash_shift = highbit(arena->m_hash_size) - 1;
360
361 for (i = 0; i < old_size; i++)
362 {
363 rtl_arena_segment_type * curr = old_table[i];
364 while (curr != NULL)
365 {
366 rtl_arena_segment_type * next = curr->m_fnext;
367 rtl_arena_segment_type ** head;
368
369 head = &(arena->m_hash_table[RTL_ARENA_HASH_INDEX(arena, curr->m_addr)]);
370 curr->m_fnext = (*head);
371 (*head) = curr;
372
373 curr = next;
374 }
375 old_table[i] = NULL;
376 }
377
378 RTL_MEMORY_LOCK_RELEASE(&(arena->m_lock));
379
380 if (old_table != arena->m_hash_table_0)
381 {
382 sal_Size old_bytes = old_size * sizeof(rtl_arena_segment_type*);
383 rtl_arena_free (gp_arena_arena, old_table, old_bytes);
384 }
385 }
386 }
387
388
389 /** rtl_arena_hash_insert()
390 * ...and update stats.
391 */
392 static RTL_MEMORY_INLINE void
rtl_arena_hash_insert(rtl_arena_type * arena,rtl_arena_segment_type * segment)393 rtl_arena_hash_insert (
394 rtl_arena_type * arena,
395 rtl_arena_segment_type * segment
396 )
397 {
398 rtl_arena_segment_type ** ppSegment;
399
400 ppSegment = &(arena->m_hash_table[RTL_ARENA_HASH_INDEX(arena, segment->m_addr)]);
401
402 segment->m_fnext = (*ppSegment);
403 (*ppSegment) = segment;
404
405 arena->m_stats.m_alloc += 1;
406 arena->m_stats.m_mem_alloc += segment->m_size;
407 }
408
409 #if defined(__SUNPRO_C) || defined(__SUNPRO_CC)
410 #pragma inline(rtl_arena_hash_insert)
411 #endif /* __SUNPRO_C */
412
413
414 /** rtl_arena_hash_remove()
415 * ...and update stats.
416 */
417 static rtl_arena_segment_type *
rtl_arena_hash_remove(rtl_arena_type * arena,sal_uIntPtr addr,sal_Size size)418 rtl_arena_hash_remove (
419 rtl_arena_type * arena,
420 sal_uIntPtr addr,
421 sal_Size size
422 )
423 {
424 rtl_arena_segment_type *segment, **segpp;
425 sal_Size lookups = 0;
426
427 #if OSL_DEBUG_LEVEL == 0
428 (void) size; /* unused */
429 #endif /* OSL_DEBUG_LEVEL */
430
431 segpp = &(arena->m_hash_table[RTL_ARENA_HASH_INDEX(arena, addr)]);
432 while ((segment = *segpp) != NULL)
433 {
434 if (segment->m_addr == addr)
435 {
436 *segpp = segment->m_fnext, segment->m_fnext = segment->m_fprev = segment;
437 break;
438 }
439
440 /* update lookup miss stats */
441 lookups += 1;
442 segpp = &(segment->m_fnext);
443 }
444
445 OSL_POSTCOND(segment != NULL, "rtl_arena_hash_remove(): bad free.");
446 if (segment != NULL)
447 {
448 OSL_POSTCOND(segment->m_size == size, "rtl_arena_hash_remove(): wrong size.");
449
450 arena->m_stats.m_free += 1;
451 arena->m_stats.m_mem_alloc -= segment->m_size;
452
453 if (lookups > 1)
454 {
455 sal_Size nseg = (sal_Size)(arena->m_stats.m_alloc - arena->m_stats.m_free);
456 if (nseg > 4 * arena->m_hash_size)
457 {
458 if (!(arena->m_flags & RTL_ARENA_FLAG_RESCALE))
459 {
460 sal_Size ave = nseg >> arena->m_hash_shift;
461 sal_Size new_size = arena->m_hash_size << (highbit(ave) - 1);
462
463 arena->m_flags |= RTL_ARENA_FLAG_RESCALE;
464 RTL_MEMORY_LOCK_RELEASE(&(arena->m_lock));
465 rtl_arena_hash_rescale (arena, new_size);
466 RTL_MEMORY_LOCK_ACQUIRE(&(arena->m_lock));
467 arena->m_flags &= ~RTL_ARENA_FLAG_RESCALE;
468 }
469 }
470 }
471 }
472
473 return (segment);
474 }
475
476 /* ================================================================= */
477
478 /** rtl_arena_segment_alloc()
479 * allocate (and remove) segment from freelist
480 *
481 * @precond arena->m_lock acquired
482 * @precond (*ppSegment == 0)
483 */
484 static int
rtl_arena_segment_alloc(rtl_arena_type * arena,sal_Size size,rtl_arena_segment_type ** ppSegment)485 rtl_arena_segment_alloc (
486 rtl_arena_type * arena,
487 sal_Size size,
488 rtl_arena_segment_type ** ppSegment
489 )
490 {
491 int index = 0;
492
493 OSL_ASSERT(*ppSegment == NULL);
494 if (!RTL_MEMORY_ISP2(size))
495 {
496 int msb = highbit(size);
497 if (RTL_ARENA_FREELIST_SIZE == SAL_INT_CAST(size_t, msb))
498 {
499 /* highest possible freelist: fall back to first fit */
500 rtl_arena_segment_type *head, *segment;
501
502 head = &(arena->m_freelist_head[msb - 1]);
503 for (segment = head->m_fnext; segment != head; segment = segment->m_fnext)
504 {
505 if (segment->m_size >= size)
506 {
507 /* allocate first fit segment */
508 (*ppSegment) = segment;
509 break;
510 }
511 }
512 goto dequeue_and_leave;
513 }
514
515 /* roundup to next power of 2 */
516 size = (1UL << msb);
517 }
518
519 index = lowbit(RTL_MEMORY_P2ALIGN(arena->m_freelist_bitmap, size));
520 if (index > 0)
521 {
522 /* instant fit: allocate first free segment */
523 rtl_arena_segment_type *head;
524
525 head = &(arena->m_freelist_head[index - 1]);
526 (*ppSegment) = head->m_fnext;
527 OSL_ASSERT((*ppSegment) != head);
528 }
529
530 dequeue_and_leave:
531 if (*ppSegment != NULL)
532 {
533 /* remove from freelist */
534 rtl_arena_freelist_remove (arena, (*ppSegment));
535 }
536 return (*ppSegment != NULL);
537 }
538
539
540 /** rtl_arena_segment_create()
541 * import new (span) segment from source arena
542 *
543 * @precond arena->m_lock acquired
544 * @precond (*ppSegment == 0)
545 */
546 static int
rtl_arena_segment_create(rtl_arena_type * arena,sal_Size size,rtl_arena_segment_type ** ppSegment)547 rtl_arena_segment_create (
548 rtl_arena_type * arena,
549 sal_Size size,
550 rtl_arena_segment_type ** ppSegment
551 )
552 {
553 OSL_ASSERT((*ppSegment) == NULL);
554 if (arena->m_source_alloc != 0)
555 {
556 rtl_arena_segment_get (arena, ppSegment);
557 if (*ppSegment != NULL)
558 {
559 rtl_arena_segment_type * span = NULL;
560 rtl_arena_segment_get (arena, &span);
561 if (span != NULL)
562 {
563 /* import new span from source arena */
564 RTL_MEMORY_LOCK_RELEASE(&(arena->m_lock));
565
566 span->m_size = size;
567 span->m_addr = (sal_uIntPtr)(arena->m_source_alloc)(
568 arena->m_source_arena, &(span->m_size));
569
570 RTL_MEMORY_LOCK_ACQUIRE(&(arena->m_lock));
571 if (span->m_addr != 0)
572 {
573 /* insert onto segment list, update stats */
574 span->m_type = RTL_ARENA_SEGMENT_TYPE_SPAN;
575 QUEUE_INSERT_HEAD_NAMED(&(arena->m_segment_head), span, s);
576 arena->m_stats.m_mem_total += span->m_size;
577
578 (*ppSegment)->m_addr = span->m_addr;
579 (*ppSegment)->m_size = span->m_size;
580 (*ppSegment)->m_type = RTL_ARENA_SEGMENT_TYPE_FREE;
581 QUEUE_INSERT_HEAD_NAMED(span, (*ppSegment), s);
582
583 /* report success */
584 return (1);
585 }
586 rtl_arena_segment_put (arena, &span);
587 }
588 rtl_arena_segment_put (arena, ppSegment);
589 }
590 }
591 return (0);
592 }
593
594
595 /** rtl_arena_segment_coalesce()
596 * mark as free and join with adjacent free segment(s)
597 *
598 * @precond arena->m_lock acquired
599 * @precond segment marked 'used'
600 */
601 static void
rtl_arena_segment_coalesce(rtl_arena_type * arena,rtl_arena_segment_type * segment)602 rtl_arena_segment_coalesce (
603 rtl_arena_type * arena,
604 rtl_arena_segment_type * segment
605 )
606 {
607 rtl_arena_segment_type *next, *prev;
608
609 /* mark segment free */
610 OSL_ASSERT(segment->m_type == RTL_ARENA_SEGMENT_TYPE_USED);
611 segment->m_type = RTL_ARENA_SEGMENT_TYPE_FREE;
612
613 /* try to merge w/ next segment */
614 next = segment->m_snext;
615 if (next->m_type == RTL_ARENA_SEGMENT_TYPE_FREE)
616 {
617 OSL_ASSERT(segment->m_addr + segment->m_size == next->m_addr);
618 segment->m_size += next->m_size;
619
620 /* remove from freelist */
621 rtl_arena_freelist_remove (arena, next);
622
623 /* remove from segment list */
624 QUEUE_REMOVE_NAMED(next, s);
625
626 /* release segment descriptor */
627 rtl_arena_segment_put (arena, &next);
628 }
629
630 /* try to merge w/ prev segment */
631 prev = segment->m_sprev;
632 if (prev->m_type == RTL_ARENA_SEGMENT_TYPE_FREE)
633 {
634 OSL_ASSERT(prev->m_addr + prev->m_size == segment->m_addr);
635 segment->m_addr = prev->m_addr;
636 segment->m_size += prev->m_size;
637
638 /* remove from freelist */
639 rtl_arena_freelist_remove (arena, prev);
640
641 /* remove from segment list */
642 QUEUE_REMOVE_NAMED(prev, s);
643
644 /* release segment descriptor */
645 rtl_arena_segment_put (arena, &prev);
646 }
647 }
648
649 /* ================================================================= */
650
651 /** rtl_arena_constructor()
652 */
653 static void
rtl_arena_constructor(void * obj)654 rtl_arena_constructor (void * obj)
655 {
656 rtl_arena_type * arena = (rtl_arena_type*)(obj);
657 rtl_arena_segment_type * head;
658 size_t i;
659
660 memset (arena, 0, sizeof(rtl_arena_type));
661
662 QUEUE_START_NAMED(arena, arena_);
663
664 (void) RTL_MEMORY_LOCK_INIT(&(arena->m_lock));
665
666 head = &(arena->m_segment_reserve_span_head);
667 rtl_arena_segment_constructor (head);
668 head->m_type = RTL_ARENA_SEGMENT_TYPE_HEAD;
669
670 head = &(arena->m_segment_reserve_head);
671 rtl_arena_segment_constructor (head);
672 head->m_type = RTL_ARENA_SEGMENT_TYPE_HEAD;
673
674 head = &(arena->m_segment_head);
675 rtl_arena_segment_constructor (head);
676 head->m_type = RTL_ARENA_SEGMENT_TYPE_HEAD;
677
678 for (i = 0; i < RTL_ARENA_FREELIST_SIZE; i++)
679 {
680 head = &(arena->m_freelist_head[i]);
681 rtl_arena_segment_constructor (head);
682
683 head->m_size = (1UL << i);
684 head->m_type = RTL_ARENA_SEGMENT_TYPE_HEAD;
685 }
686
687 arena->m_hash_table = arena->m_hash_table_0;
688 arena->m_hash_size = RTL_ARENA_HASH_SIZE;
689 arena->m_hash_shift = highbit(arena->m_hash_size) - 1;
690 }
691
692
693 /** rtl_arena_destructor()
694 */
695 static void
rtl_arena_destructor(void * obj)696 rtl_arena_destructor (void * obj)
697 {
698 rtl_arena_type * arena = (rtl_arena_type*)(obj);
699 rtl_arena_segment_type * head;
700 size_t i;
701
702 OSL_ASSERT(QUEUE_STARTED_NAMED(arena, arena_));
703
704 RTL_MEMORY_LOCK_DESTROY(&(arena->m_lock));
705
706 head = &(arena->m_segment_reserve_span_head);
707 OSL_ASSERT(head->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD);
708 rtl_arena_segment_destructor (head);
709
710 head = &(arena->m_segment_reserve_head);
711 OSL_ASSERT(head->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD);
712 rtl_arena_segment_destructor (head);
713
714 head = &(arena->m_segment_head);
715 OSL_ASSERT(head->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD);
716 rtl_arena_segment_destructor (head);
717
718 for (i = 0; i < RTL_ARENA_FREELIST_SIZE; i++)
719 {
720 head = &(arena->m_freelist_head[i]);
721
722 OSL_ASSERT(head->m_size == (1UL << i));
723 OSL_ASSERT(head->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD);
724
725 rtl_arena_segment_destructor (head);
726 }
727
728 OSL_ASSERT(arena->m_hash_table == arena->m_hash_table_0);
729 OSL_ASSERT(arena->m_hash_size == RTL_ARENA_HASH_SIZE);
730 OSL_ASSERT(
731 arena->m_hash_shift ==
732 SAL_INT_CAST(unsigned, highbit(arena->m_hash_size) - 1));
733 }
734
735 /* ================================================================= */
736
737 /** rtl_arena_activate()
738 */
739 static rtl_arena_type *
rtl_arena_activate(rtl_arena_type * arena,const char * name,sal_Size quantum,sal_Size quantum_cache_max,rtl_arena_type * source_arena,void * (SAL_CALL * source_alloc)(rtl_arena_type *,sal_Size *),void (SAL_CALL * source_free)(rtl_arena_type *,void *,sal_Size))740 rtl_arena_activate (
741 rtl_arena_type * arena,
742 const char * name,
743 sal_Size quantum,
744 sal_Size quantum_cache_max,
745 rtl_arena_type * source_arena,
746 void * (SAL_CALL * source_alloc)(rtl_arena_type *, sal_Size *),
747 void (SAL_CALL * source_free) (rtl_arena_type *, void *, sal_Size)
748 )
749 {
750 OSL_ASSERT(arena != NULL);
751 if (arena != NULL)
752 {
753 (void) snprintf (arena->m_name, sizeof(arena->m_name), "%s", name);
754
755 if (!RTL_MEMORY_ISP2(quantum))
756 {
757 /* roundup to next power of 2 */
758 quantum = (1UL << highbit(quantum));
759 }
760 quantum_cache_max = RTL_MEMORY_P2ROUNDUP(quantum_cache_max, quantum);
761
762 arena->m_quantum = quantum;
763 arena->m_quantum_shift = highbit(arena->m_quantum) - 1;
764 arena->m_qcache_max = quantum_cache_max;
765
766 arena->m_source_arena = source_arena;
767 arena->m_source_alloc = source_alloc;
768 arena->m_source_free = source_free;
769
770 if (arena->m_qcache_max > 0)
771 {
772 char name[RTL_ARENA_NAME_LENGTH + 1];
773 int i, n = (arena->m_qcache_max >> arena->m_quantum_shift);
774
775 sal_Size size = n * sizeof(rtl_cache_type*);
776 arena->m_qcache_ptr = (rtl_cache_type**)rtl_arena_alloc (gp_arena_arena, &size);
777 if (!(arena->m_qcache_ptr))
778 {
779 /* out of memory */
780 return (0);
781 }
782 for (i = 1; i <= n; i++)
783 {
784 size = i * arena->m_quantum;
785 (void) snprintf (name, sizeof(name), "%s_%lu", arena->m_name, size);
786 arena->m_qcache_ptr[i - 1] = rtl_cache_create(name, size, 0, NULL, NULL, NULL, NULL, arena, RTL_CACHE_FLAG_QUANTUMCACHE);
787 }
788 }
789
790 /* insert into arena list */
791 RTL_MEMORY_LOCK_ACQUIRE(&(g_arena_list.m_lock));
792 QUEUE_INSERT_TAIL_NAMED(&(g_arena_list.m_arena_head), arena, arena_);
793 RTL_MEMORY_LOCK_RELEASE(&(g_arena_list.m_lock));
794 }
795 return (arena);
796 }
797
798 /** rtl_arena_deactivate()
799 */
800 static void
rtl_arena_deactivate(rtl_arena_type * arena)801 rtl_arena_deactivate (
802 rtl_arena_type * arena
803 )
804 {
805 rtl_arena_segment_type * head, * segment;
806
807 /* remove from arena list */
808 RTL_MEMORY_LOCK_ACQUIRE(&(g_arena_list.m_lock));
809 QUEUE_REMOVE_NAMED(arena, arena_);
810 RTL_MEMORY_LOCK_RELEASE(&(g_arena_list.m_lock));
811
812 /* cleanup quantum cache(s) */
813 if ((arena->m_qcache_max > 0) && (arena->m_qcache_ptr != 0))
814 {
815 int i, n = (arena->m_qcache_max >> arena->m_quantum_shift);
816 for (i = 1; i <= n; i++)
817 {
818 if (arena->m_qcache_ptr[i - 1] != 0)
819 {
820 rtl_cache_destroy (arena->m_qcache_ptr[i - 1]);
821 arena->m_qcache_ptr[i - 1] = 0;
822 }
823 }
824 rtl_arena_free (
825 gp_arena_arena,
826 arena->m_qcache_ptr,
827 n * sizeof(rtl_cache_type*));
828
829 arena->m_qcache_ptr = 0;
830 }
831
832 /* check for leaked segments */
833 OSL_TRACE(
834 "rtl_arena_deactivate(\"%s\"): "
835 "allocs: %"PRIu64", frees: %"PRIu64"; total: %lu, used: %lu",
836 arena->m_name,
837 arena->m_stats.m_alloc, arena->m_stats.m_free,
838 arena->m_stats.m_mem_total, arena->m_stats.m_mem_alloc
839 );
840 if (arena->m_stats.m_alloc > arena->m_stats.m_free)
841 {
842 sal_Size i, n;
843
844 OSL_TRACE(
845 "rtl_arena_deactivate(\"%s\"): "
846 "cleaning up %"PRIu64" leaked segment(s) [%lu bytes]",
847 arena->m_name,
848 arena->m_stats.m_alloc - arena->m_stats.m_free,
849 arena->m_stats.m_mem_alloc
850 );
851
852 /* cleanup still used segment(s) */
853 for (i = 0, n = arena->m_hash_size; i < n; i++)
854 {
855 while ((segment = arena->m_hash_table[i]) != NULL)
856 {
857 /* pop from hash table */
858 arena->m_hash_table[i] = segment->m_fnext, segment->m_fnext = segment->m_fprev = segment;
859
860 /* coalesce w/ adjacent free segment(s) */
861 rtl_arena_segment_coalesce (arena, segment);
862
863 /* insert onto freelist */
864 rtl_arena_freelist_insert (arena, segment);
865 }
866 }
867 }
868
869 /* cleanup hash table */
870 if (arena->m_hash_table != arena->m_hash_table_0)
871 {
872 rtl_arena_free (
873 gp_arena_arena,
874 arena->m_hash_table,
875 arena->m_hash_size * sizeof(rtl_arena_segment_type*));
876
877 arena->m_hash_table = arena->m_hash_table_0;
878 arena->m_hash_size = RTL_ARENA_HASH_SIZE;
879 arena->m_hash_shift = highbit(arena->m_hash_size) - 1;
880 }
881
882 /* cleanup segment list */
883 head = &(arena->m_segment_head);
884 for (segment = head->m_snext; segment != head; segment = head->m_snext)
885 {
886 if (segment->m_type == RTL_ARENA_SEGMENT_TYPE_FREE)
887 {
888 /* remove from freelist */
889 rtl_arena_freelist_remove (arena, segment);
890 }
891 else
892 {
893 /* can have only free and span segments here */
894 OSL_ASSERT(segment->m_type == RTL_ARENA_SEGMENT_TYPE_SPAN);
895 }
896
897 /* remove from segment list */
898 QUEUE_REMOVE_NAMED(segment, s);
899
900 /* release segment descriptor */
901 rtl_arena_segment_put (arena, &segment);
902 }
903
904 /* cleanup segment reserve list */
905 head = &(arena->m_segment_reserve_head);
906 for (segment = head->m_snext; segment != head; segment = head->m_snext)
907 {
908 /* remove from segment list */
909 QUEUE_REMOVE_NAMED(segment, s);
910 }
911
912 /* cleanup segment reserve span(s) */
913 head = &(arena->m_segment_reserve_span_head);
914 for (segment = head->m_snext; segment != head; segment = head->m_snext)
915 {
916 /* can have only span segments here */
917 OSL_ASSERT(segment->m_type == RTL_ARENA_SEGMENT_TYPE_SPAN);
918
919 /* remove from segment list */
920 QUEUE_REMOVE_NAMED(segment, s);
921
922 /* return span to g_machdep_arena */
923 rtl_machdep_free (gp_machdep_arena, (void*)(segment->m_addr), segment->m_size);
924 }
925 }
926
927 /* ================================================================= *
928 *
929 * arena implementation.
930 *
931 * ================================================================= */
932
933 /** rtl_arena_create()
934 */
935 rtl_arena_type *
rtl_arena_create(const char * name,sal_Size quantum,sal_Size quantum_cache_max,rtl_arena_type * source_arena,void * (SAL_CALL * source_alloc)(rtl_arena_type *,sal_Size *),void (SAL_CALL * source_free)(rtl_arena_type *,void *,sal_Size),int flags)936 SAL_CALL rtl_arena_create (
937 const char * name,
938 sal_Size quantum,
939 sal_Size quantum_cache_max,
940 rtl_arena_type * source_arena,
941 void * (SAL_CALL * source_alloc)(rtl_arena_type *, sal_Size *),
942 void (SAL_CALL * source_free) (rtl_arena_type *, void *, sal_Size),
943 int flags
944 ) SAL_THROW_EXTERN_C()
945 {
946 rtl_arena_type * result = 0;
947 sal_Size size = sizeof(rtl_arena_type);
948
949 (void) flags; /* unused */
950
951 try_alloc:
952 result = (rtl_arena_type*)rtl_arena_alloc (gp_arena_arena, &size);
953 if (result != 0)
954 {
955 rtl_arena_type * arena = result;
956 VALGRIND_CREATE_MEMPOOL(arena, 0, 0);
957 rtl_arena_constructor (arena);
958
959 if (!source_arena)
960 {
961 OSL_ASSERT(gp_default_arena != 0);
962 source_arena = gp_default_arena;
963 }
964
965 result = rtl_arena_activate (
966 arena,
967 name,
968 quantum,
969 quantum_cache_max,
970 source_arena,
971 source_alloc,
972 source_free
973 );
974
975 if (result == 0)
976 {
977 rtl_arena_deactivate (arena);
978 rtl_arena_destructor (arena);
979 VALGRIND_DESTROY_MEMPOOL(arena);
980 rtl_arena_free (gp_arena_arena, arena, size);
981 }
982 }
983 else if (gp_arena_arena == 0)
984 {
985 if (rtl_arena_init())
986 {
987 /* try again */
988 goto try_alloc;
989 }
990 }
991 return (result);
992 }
993
994 /** rtl_arena_destroy()
995 */
996 void
rtl_arena_destroy(rtl_arena_type * arena)997 SAL_CALL rtl_arena_destroy (
998 rtl_arena_type * arena
999 )
1000 {
1001 if (arena != NULL)
1002 {
1003 rtl_arena_deactivate (arena);
1004 rtl_arena_destructor (arena);
1005 VALGRIND_DESTROY_MEMPOOL(arena);
1006 rtl_arena_free (gp_arena_arena, arena, sizeof(rtl_arena_type));
1007 }
1008 }
1009
1010 /** rtl_arena_alloc()
1011 */
1012 void *
rtl_arena_alloc(rtl_arena_type * arena,sal_Size * pSize)1013 SAL_CALL rtl_arena_alloc (
1014 rtl_arena_type * arena,
1015 sal_Size * pSize
1016 ) SAL_THROW_EXTERN_C()
1017 {
1018 void * addr = 0;
1019
1020 if ((arena != 0) && (pSize != 0))
1021 {
1022 sal_Size size = RTL_MEMORY_ALIGN((*pSize), arena->m_quantum);
1023 if (size > arena->m_qcache_max)
1024 {
1025 /* allocate from segment list */
1026 rtl_arena_segment_type *segment = 0;
1027
1028 RTL_MEMORY_LOCK_ACQUIRE(&(arena->m_lock));
1029 if (rtl_arena_segment_alloc (arena, size, &segment) ||
1030 rtl_arena_segment_create(arena, size, &segment) )
1031 {
1032 /* shrink to fit */
1033 sal_Size oversize;
1034
1035 /* mark segment used */
1036 OSL_ASSERT(segment->m_type == RTL_ARENA_SEGMENT_TYPE_FREE);
1037 segment->m_type = RTL_ARENA_SEGMENT_TYPE_USED;
1038
1039 /* resize */
1040 OSL_ASSERT(segment->m_size >= size);
1041 oversize = segment->m_size - size;
1042 if (oversize >= SAL_MAX(arena->m_quantum, arena->m_qcache_max))
1043 {
1044 rtl_arena_segment_type * remainder = 0;
1045 rtl_arena_segment_get (arena, &remainder);
1046 if (remainder != 0)
1047 {
1048 segment->m_size = size;
1049
1050 remainder->m_addr = segment->m_addr + segment->m_size;
1051 remainder->m_size = oversize;
1052 remainder->m_type = RTL_ARENA_SEGMENT_TYPE_FREE;
1053 QUEUE_INSERT_HEAD_NAMED(segment, remainder, s);
1054
1055 rtl_arena_freelist_insert (arena, remainder);
1056 }
1057 }
1058
1059 rtl_arena_hash_insert (arena, segment);
1060
1061 /* DEBUG ONLY: mark allocated, undefined */
1062 OSL_DEBUG_ONLY(memset((void*)(segment->m_addr), 0x77777777, segment->m_size));
1063 VALGRIND_MEMPOOL_ALLOC(arena, segment->m_addr, segment->m_size);
1064
1065 (*pSize) = segment->m_size;
1066 addr = (void*)(segment->m_addr);
1067 }
1068 RTL_MEMORY_LOCK_RELEASE(&(arena->m_lock));
1069 }
1070 else if (size > 0)
1071 {
1072 /* allocate from quantum cache(s) */
1073 int index = (size >> arena->m_quantum_shift) - 1;
1074 OSL_ASSERT (arena->m_qcache_ptr[index] != 0);
1075
1076 addr = rtl_cache_alloc (arena->m_qcache_ptr[index]);
1077 if (addr != 0)
1078 (*pSize) = size;
1079 }
1080 }
1081 return (addr);
1082 }
1083
1084 /** rtl_arena_free()
1085 */
1086 void
rtl_arena_free(rtl_arena_type * arena,void * addr,sal_Size size)1087 SAL_CALL rtl_arena_free (
1088 rtl_arena_type * arena,
1089 void * addr,
1090 sal_Size size
1091 ) SAL_THROW_EXTERN_C()
1092 {
1093 if (arena != 0)
1094 {
1095 size = RTL_MEMORY_ALIGN(size, arena->m_quantum);
1096 if (size > arena->m_qcache_max)
1097 {
1098 /* free to segment list */
1099 rtl_arena_segment_type * segment;
1100
1101 RTL_MEMORY_LOCK_ACQUIRE(&(arena->m_lock));
1102
1103 segment = rtl_arena_hash_remove (arena, (sal_uIntPtr)(addr), size);
1104 if (segment != 0)
1105 {
1106 rtl_arena_segment_type *next, *prev;
1107
1108 /* DEBUG ONLY: mark unallocated, undefined */
1109 VALGRIND_MEMPOOL_FREE(arena, segment->m_addr);
1110 /* OSL_DEBUG_ONLY() */ VALGRIND_MAKE_MEM_UNDEFINED(segment->m_addr, segment->m_size);
1111 OSL_DEBUG_ONLY(memset((void*)(segment->m_addr), 0x33333333, segment->m_size));
1112
1113 /* coalesce w/ adjacent free segment(s) */
1114 rtl_arena_segment_coalesce (arena, segment);
1115
1116 /* determine (new) next and prev segment */
1117 next = segment->m_snext, prev = segment->m_sprev;
1118
1119 /* entire span free when prev is a span, and next is either a span or a list head */
1120 if (((prev->m_type == RTL_ARENA_SEGMENT_TYPE_SPAN)) &&
1121 ((next->m_type == RTL_ARENA_SEGMENT_TYPE_SPAN) ||
1122 (next->m_type == RTL_ARENA_SEGMENT_TYPE_HEAD)) )
1123 {
1124 OSL_ASSERT((prev->m_addr == segment->m_addr) &&
1125 (prev->m_size == segment->m_size) );
1126
1127 if (arena->m_source_free)
1128 {
1129 addr = (void*)(prev->m_addr);
1130 size = prev->m_size;
1131
1132 /* remove from segment list */
1133 QUEUE_REMOVE_NAMED(segment, s);
1134
1135 /* release segment descriptor */
1136 rtl_arena_segment_put (arena, &segment);
1137
1138 /* remove from segment list */
1139 QUEUE_REMOVE_NAMED(prev, s);
1140
1141 /* release (span) segment descriptor */
1142 rtl_arena_segment_put (arena, &prev);
1143
1144 /* update stats, return span to source arena */
1145 arena->m_stats.m_mem_total -= size;
1146 RTL_MEMORY_LOCK_RELEASE(&(arena->m_lock));
1147
1148 (arena->m_source_free)(arena->m_source_arena, addr, size);
1149 return;
1150 }
1151 }
1152
1153 /* insert onto freelist */
1154 rtl_arena_freelist_insert (arena, segment);
1155 }
1156
1157 RTL_MEMORY_LOCK_RELEASE(&(arena->m_lock));
1158 }
1159 else if (size > 0)
1160 {
1161 /* free to quantum cache(s) */
1162 int index = (size >> arena->m_quantum_shift) - 1;
1163 OSL_ASSERT (arena->m_qcache_ptr[index] != 0);
1164
1165 rtl_cache_free (arena->m_qcache_ptr[index], addr);
1166 }
1167 }
1168 }
1169
1170 /* ================================================================= *
1171 *
1172 * machdep internals.
1173 *
1174 * ================================================================= */
1175
1176 #if defined(SAL_UNX)
1177 #include <sys/mman.h>
1178 #elif defined(SAL_W32) || defined(SAL_OS2)
1179 #define MAP_FAILED 0
1180 #endif /* SAL_UNX || SAL_W32 */
1181
1182 /** rtl_machdep_alloc()
1183 */
1184 static void *
rtl_machdep_alloc(rtl_arena_type * pArena,sal_Size * pSize)1185 SAL_CALL rtl_machdep_alloc (
1186 rtl_arena_type * pArena,
1187 sal_Size * pSize
1188 )
1189 {
1190 void * addr;
1191 sal_Size size = (*pSize);
1192
1193 OSL_PRECOND(pArena == gp_machdep_arena, "rtl_machdep_alloc(): invalid argument");
1194
1195 #if defined(SOLARIS) && defined(SPARC)
1196 /* see @ mmap(2) man pages */
1197 size += (pArena->m_quantum + pArena->m_quantum); /* "red-zone" pages */
1198 if (size > (4 << 20))
1199 size = RTL_MEMORY_P2ROUNDUP(size, (4 << 20));
1200 else if (size > (512 << 10))
1201 size = RTL_MEMORY_P2ROUNDUP(size, (512 << 10));
1202 else
1203 size = RTL_MEMORY_P2ROUNDUP(size, (64 << 10));
1204 size -= (pArena->m_quantum + pArena->m_quantum); /* "red-zone" pages */
1205 #else
1206 /* default allocation granularity */
1207 size = RTL_MEMORY_P2ROUNDUP(size, SAL_MAX(pArena->m_quantum, 64 << 10));
1208 #endif
1209
1210 #if defined(SAL_UNX)
1211 addr = mmap (NULL, (size_t)(size), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
1212 #elif defined(SAL_W32)
1213 addr = VirtualAlloc (NULL, (SIZE_T)(size), MEM_COMMIT, PAGE_READWRITE);
1214 #elif defined(SAL_OS2)
1215 /* Use valloc() to use libc 16MB chunks when allocating high memory, to reduce
1216 virtual address fragmentation. */
1217 addr = valloc( size);
1218 #endif /* (SAL_UNX || SAL_W32 || SAL_OS2) */
1219
1220 if (addr != MAP_FAILED)
1221 {
1222 pArena->m_stats.m_alloc += 1;
1223 pArena->m_stats.m_mem_total += size;
1224 pArena->m_stats.m_mem_alloc += size;
1225
1226 (*pSize) = size;
1227 return (addr);
1228 }
1229 return (NULL);
1230 }
1231
1232 /** rtl_machdep_free()
1233 */
1234 static void
rtl_machdep_free(rtl_arena_type * pArena,void * pAddr,sal_Size nSize)1235 SAL_CALL rtl_machdep_free (
1236 rtl_arena_type * pArena,
1237 void * pAddr,
1238 sal_Size nSize
1239 )
1240 {
1241 OSL_PRECOND(pArena == gp_machdep_arena, "rtl_machdep_free(): invalid argument");
1242
1243 pArena->m_stats.m_free += 1;
1244 pArena->m_stats.m_mem_total -= nSize;
1245 pArena->m_stats.m_mem_alloc -= nSize;
1246
1247 #if defined(SAL_UNX)
1248 (void) munmap(pAddr, nSize);
1249 #elif defined(SAL_W32)
1250 (void) VirtualFree ((LPVOID)(pAddr), (SIZE_T)(0), MEM_RELEASE);
1251 #elif defined(SAL_OS2)
1252 free(pAddr);
1253 #endif /* (SAL_UNX || SAL_W32) */
1254 }
1255
1256 /** rtl_machdep_pagesize()
1257 */
1258 static sal_Size
rtl_machdep_pagesize(void)1259 rtl_machdep_pagesize (void)
1260 {
1261 #if defined(SAL_UNX)
1262 #if defined(FREEBSD) || defined(NETBSD)
1263 return ((sal_Size)getpagesize());
1264 #else /* POSIX */
1265 return ((sal_Size)sysconf(_SC_PAGESIZE));
1266 #endif /* xBSD || POSIX */
1267 #elif defined(SAL_W32)
1268 SYSTEM_INFO info;
1269 GetSystemInfo (&info);
1270 return ((sal_Size)(info.dwPageSize));
1271 #elif defined(SAL_OS2)
1272 ULONG ulPageSize;
1273 DosQuerySysInfo(QSV_PAGE_SIZE, QSV_PAGE_SIZE, &ulPageSize, sizeof(ULONG));
1274 return ((sal_Size)ulPageSize);
1275 #endif /* (SAL_UNX || SAL_W32) */
1276 }
1277
1278 /* ================================================================= *
1279 *
1280 * arena initialization.
1281 *
1282 * ================================================================= */
1283
1284 static void
rtl_arena_once_init(void)1285 rtl_arena_once_init (void)
1286 {
1287 {
1288 /* list of arenas */
1289 RTL_MEMORY_LOCK_INIT(&(g_arena_list.m_lock));
1290 rtl_arena_constructor (&(g_arena_list.m_arena_head));
1291 }
1292 {
1293 /* machdep (pseudo) arena */
1294 static rtl_arena_type g_machdep_arena;
1295
1296 OSL_ASSERT(gp_machdep_arena == NULL);
1297 VALGRIND_CREATE_MEMPOOL(&g_machdep_arena, 0, 0);
1298 rtl_arena_constructor (&g_machdep_arena);
1299
1300 gp_machdep_arena = rtl_arena_activate (
1301 &g_machdep_arena,
1302 "rtl_machdep_arena",
1303 rtl_machdep_pagesize(),
1304 0, /* no quantum caching */
1305 0, 0, 0 /* no source */
1306 );
1307 OSL_ASSERT(gp_machdep_arena != NULL);
1308 }
1309 {
1310 /* default arena */
1311 static rtl_arena_type g_default_arena;
1312
1313 OSL_ASSERT(gp_default_arena == NULL);
1314 VALGRIND_CREATE_MEMPOOL(&g_default_arena, 0, 0);
1315 rtl_arena_constructor (&g_default_arena);
1316
1317 gp_default_arena = rtl_arena_activate (
1318 &g_default_arena,
1319 "rtl_default_arena",
1320 rtl_machdep_pagesize(),
1321 0, /* no quantum caching */
1322 gp_machdep_arena, /* source */
1323 rtl_machdep_alloc,
1324 rtl_machdep_free
1325 );
1326 OSL_ASSERT(gp_default_arena != NULL);
1327 }
1328 {
1329 /* arena internal arena */
1330 static rtl_arena_type g_arena_arena;
1331
1332 OSL_ASSERT(gp_arena_arena == NULL);
1333 VALGRIND_CREATE_MEMPOOL(&g_arena_arena, 0, 0);
1334 rtl_arena_constructor (&g_arena_arena);
1335
1336 gp_arena_arena = rtl_arena_activate (
1337 &g_arena_arena,
1338 "rtl_arena_internal_arena",
1339 64, /* quantum */
1340 0, /* no quantum caching */
1341 gp_default_arena, /* source */
1342 rtl_arena_alloc,
1343 rtl_arena_free
1344 );
1345 OSL_ASSERT(gp_arena_arena != NULL);
1346 }
1347 }
1348
1349 static int
rtl_arena_init(void)1350 rtl_arena_init (void)
1351 {
1352 static sal_once_type g_once = SAL_ONCE_INIT;
1353 SAL_ONCE(&g_once, rtl_arena_once_init);
1354 return (gp_arena_arena != NULL);
1355 }
1356
1357 /* ================================================================= */
1358
1359 /*
1360 Issue http://udk.openoffice.org/issues/show_bug.cgi?id=92388
1361
1362 Mac OS X does not seem to support "__cxa__atexit", thus leading
1363 to the situation that "__attribute__((destructor))__" functions
1364 (in particular "rtl_{memory|cache|arena}_fini") become called
1365 _before_ global C++ object d'tors.
1366
1367 Delegated the call to "rtl_arena_fini()" into a dummy C++ object,
1368 see alloc_fini.cxx .
1369 */
1370 #if defined(__GNUC__) && !defined(MACOSX)
1371 static void rtl_arena_fini (void) __attribute__((destructor));
1372 #elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
1373 #pragma fini(rtl_arena_fini)
1374 static void rtl_arena_fini (void);
1375 #endif /* __GNUC__ || __SUNPRO_C */
1376
1377 void
rtl_arena_fini(void)1378 rtl_arena_fini (void)
1379 {
1380 if (gp_arena_arena != NULL)
1381 {
1382 rtl_arena_type * arena, * head;
1383
1384 RTL_MEMORY_LOCK_ACQUIRE(&(g_arena_list.m_lock));
1385 head = &(g_arena_list.m_arena_head);
1386
1387 for (arena = head->m_arena_next; arena != head; arena = arena->m_arena_next)
1388 {
1389 OSL_TRACE(
1390 "rtl_arena_fini(\"%s\"): "
1391 "allocs: %"PRIu64", frees: %"PRIu64"; total: %lu, used: %lu",
1392 arena->m_name,
1393 arena->m_stats.m_alloc, arena->m_stats.m_free,
1394 arena->m_stats.m_mem_total, arena->m_stats.m_mem_alloc
1395 );
1396 }
1397 RTL_MEMORY_LOCK_RELEASE(&(g_arena_list.m_lock));
1398 }
1399 }
1400
1401 /* ================================================================= */
1402