sal/rtl/source/alloc_arena.c

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