src/gc/api.c

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/gc/api.c - general Parrot API for GC functions
   8
   9 =head1 DESCRIPTION
  10
  11 This file implements the external-facing API for Parrot's garbage collector.
  12 The collector itself is composed of various interchangable cores that each
  13 may operate very differently internally. The functions in this file can be used
  14 throughout Parrot without having to be concerned about the internal operations
  15 of the GC. This is documented in PDD 9 with supplementary notes in
  16 F<docs/memory_internals.pod>.
  17
  18 =head1 GC OVERVIEW
  19
  20 The GC is broken into a number of different files that each represent different
  21 components.
  22
  23 =over 4
  24
  25 =item F<src/gc/api.c>
  26
  27 This is the main API file which provides access to functions which are used by
  28 the rest of Parrot core. In the long term, only the functions provided in this
  29 file should be visible to files outside the src/gc/ directory. Because this
  30 represents a public-facing API, the functions in this file are not related by
  31 theme.
  32
  33 =item F<src/gc/alloc_memory.c>
  34
  35 This file provides a number of functions and macros for allocating memory from
  36 the OS. These are typically wrapper functions with error-handling capabilities
  37 over malloc, calloc, or realloc.
  38
  39 =item F<src/gc/alloc_register.c>
  40
  41 This file implements the custom management and interface logic for
  42 Parrot_Context structures. The functions in this file are publicly available
  43 and are used throughout Parrot core for interacting with contexts and registers
  44
  45 =item F<src/gc/alloc_resources.c>
  46
  47 This file implements handling logic for strings and arbitrary-sized memory
  48 buffers. String storage is managed by special Variable_Size_Pool structures, and use
  49 a separate compacting garbage collector to keep track of them.
  50
  51 =item F<src/gc/incremental_ms.c>
  52
  53 =item F<src/gc/generational_ms.c>
  54
  55 =item F<src/gc/gc_ms.c>
  56
  57 These files are the individual GC cores which implement the primary tracing
  58 and sweeping logic. gc_ms.c is the mark & sweep collector core which is used in
  59 Parrot by default. generational_ms.c is an experimental and incomplete
  60 generational core.  incremental_ms.c is an experimental and incomplete
  61 incremental collector core.
  62
  63 =item F<src/gc/mark_sweep.c>
  64
  65 This file implements some routines that are commonly needed by the various GC
  66 cores and provide an abstraction layer that a GC core can use to interact with
  67 some of the architecture of Parrot.
  68
  69 =item F<src/gc/system.c>
  70
  71 This file implements logic for tracing processor registers and the system stack.
  72 Here there be dragons.
  73
  74 =item F<src/gc/malloc.c>
  75
  76 =item F<src/gc/malloc_trace.c>
  77
  78 These two files implement various unused features, including a custom malloc
  79 implementation, and malloc wrappers for various purposes. These are unused.
  80
  81 =back
  82
  83
  84 =head1 FUNCTIONS
  85
  86 =over 4
  87
  88 =cut
  89
  90 */
  91
  92 #define GC_C_SOURCE
  93 #include "parrot/parrot.h"
  94 #include "parrot/gc_api.h"
  95 #include "gc_private.h"
  96
  97 /* HEADERIZER HFILE: include/parrot/gc_api.h */
  98
  99 /* HEADERIZER BEGIN: static */
 100 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 101
 102 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
 103 /* HEADERIZER END: static */
 104
 105 #if ! DISABLE_GC_DEBUG
 106
 107 #endif
 108
 109 /*
 110
 111 =item C<void Parrot_gc_mark_PObj_alive(PARROT_INTERP, PObj *obj)>
 112
 113 Marks the PObj as "alive" for the Garbage Collector. Takes a pointer to a PObj,
 114 and performs necessary marking to ensure the PMC and its direct children nodes
 115 are marked alive. Implementation is generally dependant on the particular
 116 garbage collector in use.
 117
 118 Previously known as C<pobject_lives>.
 119
 120 =cut
 121
 122 */
 123
 124 PARROT_EXPORT
 125 void
 126 Parrot_gc_mark_PObj_alive(PARROT_INTERP, ARGMOD(PObj *obj))
 127 {
 128     ASSERT_ARGS(Parrot_gc_mark_PObj_alive)
 129     /* TODO: Have each core register a ->pobject_lives function pointer in the
 130        Memory_Pools struct, and call that pointer directly instead of having a messy
 131        set of #if preparser conditions. */
 132
 133     /* if object is live or on free list return */
 134     if (PObj_is_live_or_free_TESTALL(obj))
 135         return;
 136
 137     /* mark it live */
 138     PObj_live_SET(obj);
 139
 140     /* if object is a PMC and contains buffers or PMCs, then attach the PMC
 141      * to the chained mark list. */
 142     if (PObj_is_PMC_TEST(obj)) {
 143         PMC * const p = (PMC *)obj;
 144
 145         if (PObj_is_special_PMC_TEST(obj))
 146             interp->gc_sys->mark_special(interp, p);
 147
 148         else if (PMC_metadata(p))
 149             Parrot_gc_mark_PMC_alive(interp, PMC_metadata(p));
 150     }
 151 }
 152
 153 /*
 154
 155 =item C<void Parrot_gc_mark_PMC_alive_fun(PARROT_INTERP, PMC *obj)>
 156
 157 A type safe wrapper of Parrot_gc_mark_PObj_alive for PMC.
 158
 159 =cut
 160
 161 */
 162
 163 PARROT_EXPORT
 164 void
 165 Parrot_gc_mark_PMC_alive_fun(PARROT_INTERP, ARGMOD_NULLOK(PMC *obj))
 166 {
 167     ASSERT_ARGS(Parrot_gc_mark_PMC_alive_fun)
 168     if (!PMC_IS_NULL(obj)) {
 169         PARROT_ASSERT(PObj_is_PMC_TEST(obj));
 170
 171         if (PObj_is_live_or_free_TESTALL(obj))
 172             return;
 173
 174         /* mark it live */
 175         PObj_live_SET(obj);
 176
 177         /* if object is a PMC and contains buffers or PMCs, then attach the PMC
 178          * to the chained mark list. */
 179         if (PObj_is_special_PMC_TEST(obj)) {
 180             if (PObj_custom_mark_TEST(obj))
 181                 VTABLE_mark(interp, obj);
 182         }
 183
 184         if (PMC_metadata(obj))
 185             Parrot_gc_mark_PMC_alive(interp, PMC_metadata(obj));
 186     }
 187 }
 188
 189 /*
 190
 191 =item C<void Parrot_gc_mark_STRING_alive_fun(PARROT_INTERP, STRING *obj)>
 192
 193 A type safe wrapper of Parrot_gc_mark_PObj_alive for STRING.
 194
 195 =cut
 196
 197 */
 198
 199 PARROT_EXPORT
 200 void
 201 Parrot_gc_mark_STRING_alive_fun(SHIM_INTERP, ARGMOD_NULLOK(STRING *obj))
 202 {
 203     ASSERT_ARGS(Parrot_gc_mark_STRING_alive_fun)
 204     if (!STRING_IS_NULL(obj)) {
 205         PARROT_ASSERT(PObj_is_string_TEST(obj));
 206
 207         /* mark it live */
 208         PObj_live_SET(obj);
 209     }
 210 }
 211
 212 /*
 213
 214 =item C<void Parrot_gc_initialize(PARROT_INTERP, void *stacktop)>
 215
 216 Initializes the memory allocator and the garbage collection subsystem.
 217 Calls the initialization function associated with each collector, which
 218 is determined at compile time.
 219
 220 The "stacktop" parameter is required; it provides an upper bound for
 221 stack scanning during a garbage collection run.
 222
 223 =cut
 224
 225 */
 226
 227 void
 228 Parrot_gc_initialize(PARROT_INTERP, ARGIN(void *stacktop))
 229 {
 230     ASSERT_ARGS(Parrot_gc_initialize)
 231
 232     interp->lo_var_ptr                    = stacktop;
 233
 234     /*Call appropriate initialization function for GC subsystem*/
 235     switch (interp->gc_sys->sys_type) {
 236       case MS:
 237         Parrot_gc_ms_init(interp);
 238         break;
 239       case INF:
 240         Parrot_gc_inf_init(interp);
 241         break;
 242       default:
 243         /*die horribly because of invalid GC core specified*/
 244         break;
 245     };
 246
 247     /* Assertions that GC subsystem has complete API */
 248     PARROT_ASSERT(interp->gc_sys->do_gc_mark);
 249     PARROT_ASSERT(interp->gc_sys->compact_string_pool);
 250
 251     /* It should be mandatory. But there is abstraction leak in */
 252     /* mark_foo_alive. */
 253     /* PARROT_ASSERT(interp->gc_sys->mark_special); */
 254
 255     PARROT_ASSERT(interp->gc_sys->allocate_pmc_header);
 256     PARROT_ASSERT(interp->gc_sys->free_pmc_header);
 257
 258     PARROT_ASSERT(interp->gc_sys->allocate_string_header);
 259     PARROT_ASSERT(interp->gc_sys->free_string_header);
 260
 261     PARROT_ASSERT(interp->gc_sys->allocate_bufferlike_header);
 262     PARROT_ASSERT(interp->gc_sys->free_bufferlike_header);
 263
 264     PARROT_ASSERT(interp->gc_sys->allocate_pmc_attributes);
 265     PARROT_ASSERT(interp->gc_sys->free_pmc_attributes);
 266
 267     PARROT_ASSERT(interp->gc_sys->allocate_string_storage);
 268     PARROT_ASSERT(interp->gc_sys->reallocate_string_storage);
 269
 270     PARROT_ASSERT(interp->gc_sys->allocate_buffer_storage);
 271     PARROT_ASSERT(interp->gc_sys->reallocate_buffer_storage);
 272
 273     PARROT_ASSERT(interp->gc_sys->allocate_fixed_size_storage);
 274     PARROT_ASSERT(interp->gc_sys->free_fixed_size_storage);
 275
 276     PARROT_ASSERT(interp->gc_sys->allocate_memory_chunk);
 277     PARROT_ASSERT(interp->gc_sys->reallocate_memory_chunk);
 278     PARROT_ASSERT(interp->gc_sys->allocate_memory_chunk_with_interior_pointers);
 279     PARROT_ASSERT(interp->gc_sys->reallocate_memory_chunk_with_interior_pointers);
 280     PARROT_ASSERT(interp->gc_sys->free_memory_chunk);
 281
 282     PARROT_ASSERT(interp->gc_sys->get_gc_info);
 283 }
 284
 285 /*
 286
 287 =item C<void Parrot_gc_finalize(PARROT_INTERP)>
 288
 289 Finalize the GC system, if the current GC core has defined a finalization
 290 routine.
 291
 292 =cut
 293
 294 */
 295
 296 void
 297 Parrot_gc_finalize(PARROT_INTERP)
 298 {
 299     ASSERT_ARGS(Parrot_gc_finalize)
 300     if (interp->gc_sys->finalize_gc_system)
 301         interp->gc_sys->finalize_gc_system(interp);
 302
 303     mem_internal_free(interp->gc_sys);
 304     interp->gc_sys = NULL;
 305 }
 306
 307
 308 /*
 309
 310 =item C<PMC * Parrot_gc_new_pmc_header(PARROT_INTERP, UINTVAL flags)>
 311
 312 Gets a new PMC header from the PMC pool's free list. Guaranteed to return a
 313 valid PMC object or else Parrot will throw an exception. Sets the necessary
 314 flags for the objects and initializes the PMC data pointer to C<NULL>.
 315
 316 =cut
 317
 318 */
 319
 320 PARROT_WARN_UNUSED_RESULT
 321 PARROT_CANNOT_RETURN_NULL
 322 PMC *
 323 Parrot_gc_new_pmc_header(PARROT_INTERP, UINTVAL flags)
 324 {
 325     ASSERT_ARGS(Parrot_gc_new_pmc_header)
 326     PMC * const pmc = interp->gc_sys->allocate_pmc_header(interp, flags);
 327
 328     if (!pmc)
 329         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ALLOCATION_ERROR,
 330             "Parrot VM: PMC allocation failed!\n");
 331
 332     PObj_get_FLAGS(pmc) = PObj_is_PMC_FLAG|flags;
 333     pmc->vtable         = NULL;
 334     PMC_data(pmc)       = NULL;
 335     PMC_metadata(pmc)   = PMCNULL;
 336
 337     return pmc;
 338 }
 339
 340 /*
 341
 342 =item C<void Parrot_gc_free_pmc_header(PARROT_INTERP, PMC *pmc)>
 343
 344 Adds the given PMC to the free list for later reuse.
 345
 346 =cut
 347
 348 */
 349
 350 void
 351 Parrot_gc_free_pmc_header(PARROT_INTERP, ARGMOD(PMC *pmc))
 352 {
 353     ASSERT_ARGS(Parrot_gc_free_pmc_header)
 354     interp->gc_sys->free_pmc_header(interp, pmc);
 355 }
 356
 357 /*
 358
 359 =item C<STRING * Parrot_gc_new_string_header(PARROT_INTERP, UINTVAL flags)>
 360
 361 Returns a new C<STRING> header from the string pool or the constant string
 362 pool. Sets default flags on the string object: C<PObj_is_string_FLAG> and
 363 C<PObj_is_COWable_FLAG>. Initializes the data field of the string buffer to
 364 C<NULL>.
 365
 366 =cut
 367
 368 */
 369
 370 PARROT_CANNOT_RETURN_NULL
 371 PARROT_WARN_UNUSED_RESULT
 372 STRING *
 373 Parrot_gc_new_string_header(PARROT_INTERP, UINTVAL flags)
 374 {
 375     ASSERT_ARGS(Parrot_gc_new_string_header)
 376
 377     STRING * const string = interp->gc_sys->allocate_string_header(interp, flags);
 378     if (!string)
 379         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ALLOCATION_ERROR,
 380             "Parrot VM: STRING allocation failed!\n");
 381
 382     string->strstart        = NULL;
 383     PObj_get_FLAGS(string) |=
 384         flags | PObj_is_string_FLAG | PObj_is_COWable_FLAG;
 385
 386     return string;
 387 }
 388
 389 /*
 390
 391 =item C<void Parrot_gc_free_string_header(PARROT_INTERP, STRING *s)>
 392
 393 Adds the given STRING to the free list for later reuse.
 394
 395 =cut
 396
 397 */
 398
 399 void
 400 Parrot_gc_free_string_header(PARROT_INTERP, ARGMOD(STRING *s))
 401 {
 402     ASSERT_ARGS(Parrot_gc_free_string_header)
 403     interp->gc_sys->free_string_header(interp, s);
 404 }
 405
 406 /*
 407
 408 =item C<Buffer * Parrot_gc_new_bufferlike_header(PARROT_INTERP, size_t size)>
 409
 410 Returns a new buffer-like header from the appropriate sized pool.
 411 A "bufferlike object" is an object that is considered to be isomorphic to the
 412 PObj, so it will participate in normal GC. At the moment these are only used
 413 to create ListChunk objects in src/list.c.
 414
 415 =cut
 416
 417 */
 418
 419 PARROT_CANNOT_RETURN_NULL
 420 PARROT_WARN_UNUSED_RESULT
 421 Buffer *
 422 Parrot_gc_new_bufferlike_header(PARROT_INTERP, size_t size)
 423 {
 424     ASSERT_ARGS(Parrot_gc_new_bufferlike_header)
 425     return interp->gc_sys->allocate_bufferlike_header(interp, size);
 426 }
 427
 428 /*
 429
 430 =item C<void Parrot_gc_free_bufferlike_header(PARROT_INTERP, Buffer *obj, size_t
 431 size)>
 432
 433 Free a bufferlike header that is not being used, so that Parrot can recycle
 434 it and use it again.
 435
 436 =cut
 437
 438 */
 439
 440 void
 441 Parrot_gc_free_bufferlike_header(PARROT_INTERP, ARGMOD(Buffer *obj),
 442     size_t size)
 443 {
 444     ASSERT_ARGS(Parrot_gc_free_bufferlike_header)
 445     interp->gc_sys->free_bufferlike_header(interp, obj, size);
 446 }
 447
 448 /*
 449
 450 =item C<void Parrot_gc_allocate_buffer_storage_aligned(PARROT_INTERP, Buffer
 451 *buffer, size_t size)>
 452
 453 Allocates a chunk of memory of at least size C<size> for the given Buffer.
 454 buffer is guaranteed to be properly aligned for things like C<FLOATVALS>,
 455 so the size may be rounded up or down to guarantee that this alignment holds.
 456
 457 =cut
 458
 459 */
 460
 461 void
 462 Parrot_gc_allocate_buffer_storage_aligned(PARROT_INTERP,
 463     ARGOUT(Buffer *buffer), size_t size)
 464 {
 465     ASSERT_ARGS(Parrot_gc_allocate_buffer_storage_aligned)
 466     interp->gc_sys->allocate_buffer_storage(interp, buffer, size);
 467 }
 468
 469 /*
 470
 471 =item C<void Parrot_gc_reallocate_buffer_storage(PARROT_INTERP, Buffer *buffer,
 472 size_t newsize)>
 473
 474 Reallocate the Buffer's buffer memory to the given size. The
 475 allocated buffer will not shrink. If the buffer was allocated with
 476 L<Parrot_allocate_aligned> the new buffer will also be aligned. As with
 477 all reallocation, the new buffer might have moved and the additional
 478 memory is not cleared.
 479
 480 =cut
 481
 482 */
 483
 484 void
 485 Parrot_gc_reallocate_buffer_storage(PARROT_INTERP, ARGMOD(Buffer *buffer),
 486     size_t newsize)
 487 {
 488     ASSERT_ARGS(Parrot_gc_reallocate_buffer_storage)
 489     interp->gc_sys->reallocate_buffer_storage(interp, buffer, newsize);
 490 }
 491
 492 /*
 493
 494 =item C<void Parrot_gc_allocate_string_storage(PARROT_INTERP, STRING *str,
 495 size_t size)>
 496
 497 Allocate the STRING's buffer memory to the given size. The allocated
 498 buffer maybe slightly bigger than the given C<size>. This function
 499 sets also C<< str->strstart >> to the new buffer location, C<< str->bufused >>
 500 is B<not> changed.
 501
 502 =cut
 503
 504 */
 505
 506 void
 507 Parrot_gc_allocate_string_storage(PARROT_INTERP, ARGOUT(STRING *str),
 508     size_t size)
 509 {
 510     ASSERT_ARGS(Parrot_gc_allocate_string_storage)
 511     interp->gc_sys->allocate_string_storage(interp, str, size);
 512 }
 513
 514 /*
 515
 516 =item C<void Parrot_gc_reallocate_string_storage(PARROT_INTERP, STRING *str,
 517 size_t newsize)>
 518
 519 Reallocate the STRING's buffer memory to the given size. The allocated
 520 buffer will not shrink. This function sets also C<str-E<gt>strstart> to the
 521 new buffer location, C<str-E<gt>bufused> is B<not> changed.
 522
 523 =cut
 524
 525 */
 526
 527 void
 528 Parrot_gc_reallocate_string_storage(PARROT_INTERP, ARGMOD(STRING *str),
 529     size_t newsize)
 530 {
 531     ASSERT_ARGS(Parrot_gc_reallocate_string_storage)
 532     interp->gc_sys->reallocate_string_storage(interp, str, newsize);
 533 }
 534
 535 /*
 536
 537 =item C<void * Parrot_gc_allocate_pmc_attributes(PARROT_INTERP, PMC *pmc)>
 538
 539 Allocates a new attribute structure for a PMC if it has the auto_attrs flag
 540 set.
 541
 542 =cut
 543
 544 */
 545
 546 PARROT_CANNOT_RETURN_NULL
 547 void *
 548 Parrot_gc_allocate_pmc_attributes(PARROT_INTERP, ARGMOD(PMC *pmc))
 549 {
 550     ASSERT_ARGS(Parrot_gc_allocate_pmc_attributes)
 551     return interp->gc_sys->allocate_pmc_attributes(interp, pmc);
 552 }
 553
 554 /*
 555
 556 =item C<void Parrot_gc_free_pmc_attributes(PARROT_INTERP, PMC *pmc)>
 557
 558 Deallocates an attibutes structure from a PMC if it has the auto_attrs
 559 flag set.
 560
 561 */
 562
 563 void
 564 Parrot_gc_free_pmc_attributes(PARROT_INTERP, ARGMOD(PMC *pmc))
 565 {
 566     ASSERT_ARGS(Parrot_gc_free_pmc_attributes)
 567     interp->gc_sys->free_pmc_attributes(interp, pmc);
 568 }
 569
 570 /*
 571
 572 =item C<void * Parrot_gc_allocate_fixed_size_storage(PARROT_INTERP, size_t
 573 size)>
 574
 575 Allocates a fixed-size chunk of memory for use. This memory is not manually
 576 managed and needs to be freed with C<Parrot_gc_free_fixed_size_storage>
 577
 578 */
 579
 580 PARROT_CANNOT_RETURN_NULL
 581 void *
 582 Parrot_gc_allocate_fixed_size_storage(PARROT_INTERP, size_t size)
 583 {
 584     ASSERT_ARGS(Parrot_gc_allocate_fixed_size_storage)
 585     return interp->gc_sys->allocate_fixed_size_storage(interp, size);
 586 }
 587
 588 /*
 589
 590 =item C<void Parrot_gc_free_fixed_size_storage(PARROT_INTERP, size_t size, void
 591 *data)>
 592
 593 Manually deallocates fixed size storage allocated with
 594 C<Parrot_gc_allocate_fixed_size_storage>
 595
 596 */
 597
 598 void
 599 Parrot_gc_free_fixed_size_storage(PARROT_INTERP, size_t size, ARGMOD(void *data))
 600 {
 601     ASSERT_ARGS(Parrot_gc_free_fixed_size_storage)
 602     interp->gc_sys->free_fixed_size_storage(interp, size, data);
 603 }
 604
 605 /*
 606
 607 =item C<void * Parrot_gc_allocate_memory_chunk(PARROT_INTERP, size_t size)>
 608
 609 =item C<void * Parrot_gc_reallocate_memory_chunk(PARROT_INTERP, void *data,
 610 size_t newsize)>
 611
 612 =item C<void Parrot_gc_free_memory_chunk(PARROT_INTERP, void *data)>
 613
 614 =item C<void *
 615 Parrot_gc_allocate_memory_chunk_with_interior_pointers(PARROT_INTERP, size_t
 616 size)>
 617
 618 =item C<void *
 619 Parrot_gc_reallocate_memory_chunk_with_interior_pointers(PARROT_INTERP, void
 620 *data, size_t newsize, size_t oldsize)>
 621
 622 TODO Write docu.
 623
 624 */
 625
 626 PARROT_EXPORT
 627 PARROT_CANNOT_RETURN_NULL
 628 void *
 629 Parrot_gc_allocate_memory_chunk(PARROT_INTERP, size_t size)
 630 {
 631     ASSERT_ARGS(Parrot_gc_allocate_memory_chunk)
 632     return interp->gc_sys->allocate_memory_chunk(interp, size);
 633 }
 634
 635 PARROT_EXPORT
 636 PARROT_CANNOT_RETURN_NULL
 637 void *
 638 Parrot_gc_reallocate_memory_chunk(PARROT_INTERP, ARGFREE(void *data), size_t newsize)
 639 {
 640     ASSERT_ARGS(Parrot_gc_reallocate_memory_chunk)
 641     return interp->gc_sys->reallocate_memory_chunk(interp, data, newsize);
 642 }
 643
 644 PARROT_EXPORT
 645 PARROT_CANNOT_RETURN_NULL
 646 void
 647 Parrot_gc_free_memory_chunk(PARROT_INTERP, ARGIN_NULLOK(void *data))
 648 {
 649     ASSERT_ARGS(Parrot_gc_free_memory_chunk)
 650     interp->gc_sys->free_memory_chunk(interp, data);
 651 }
 652
 653
 654 PARROT_EXPORT
 655 PARROT_CANNOT_RETURN_NULL
 656 void *
 657 Parrot_gc_allocate_memory_chunk_with_interior_pointers(PARROT_INTERP, size_t size)
 658 {
 659     ASSERT_ARGS(Parrot_gc_allocate_memory_chunk_with_interior_pointers)
 660     return interp->gc_sys->allocate_memory_chunk_with_interior_pointers(interp, size);
 661 }
 662
 663 PARROT_EXPORT
 664 PARROT_CANNOT_RETURN_NULL
 665 void *
 666 Parrot_gc_reallocate_memory_chunk_with_interior_pointers(PARROT_INTERP,
 667         ARGFREE(void *data), size_t newsize, size_t oldsize)
 668 {
 669     ASSERT_ARGS(Parrot_gc_reallocate_memory_chunk_with_interior_pointers)
 670     return interp->gc_sys->reallocate_memory_chunk_with_interior_pointers(interp,
 671             data, newsize, oldsize);
 672 }
 673
 674
 675 /*
 676
 677 =item C<void Parrot_gc_mark_and_sweep(PARROT_INTERP, UINTVAL flags)>
 678
 679 Calls the configured garbage collector to find and reclaim unused
 680 headers. Performs a complete mark & sweep run of the GC.
 681
 682 =cut
 683
 684 */
 685
 686 void
 687 Parrot_gc_mark_and_sweep(PARROT_INTERP, UINTVAL flags)
 688 {
 689     ASSERT_ARGS(Parrot_gc_mark_and_sweep)
 690     interp->gc_sys->do_gc_mark(interp, flags);
 691 }
 692
 693 /*
 694
 695 =item C<void Parrot_gc_compact_memory_pool(PARROT_INTERP)>
 696
 697 Compact string pool if supported by GC.
 698
 699 =cut
 700
 701 */
 702
 703 void
 704 Parrot_gc_compact_memory_pool(PARROT_INTERP)
 705 {
 706     ASSERT_ARGS(Parrot_gc_compact_memory_pool)
 707     interp->gc_sys->compact_string_pool(interp);
 708 }
 709
 710 /*
 711
 712 =item C<void Parrot_gc_destroy_child_interp(Interp *dest_interp, Interp
 713 *source_interp)>
 714
 715 Merges the header pools of C<source_interp> into those of C<dest_interp>.
 716 (Used to deal with shared objects left after interpreter destruction.)
 717
 718 =cut
 719
 720 */
 721
 722 void
 723 Parrot_gc_destroy_child_interp(ARGMOD(Interp *dest_interp),
 724     ARGIN(Interp *source_interp))
 725 {
 726     ASSERT_ARGS(Parrot_gc_destroy_child_interp)
 727     if (dest_interp->gc_sys->destroy_child_interp)
 728         dest_interp->gc_sys->destroy_child_interp(dest_interp, source_interp);
 729 }
 730
 731 /*
 732
 733 =item C<int Parrot_gc_active_sized_buffers(PARROT_INTERP)>
 734
 735 Returns the number of actively used sized buffers.
 736
 737 =cut
 738
 739 */
 740
 741 int
 742 Parrot_gc_active_sized_buffers(PARROT_INTERP)
 743 {
 744     ASSERT_ARGS(Parrot_gc_active_sized_buffers)
 745     return interp->gc_sys->get_gc_info(interp, ACTIVE_BUFFERS);
 746 }
 747
 748 /*
 749
 750 =item C<int Parrot_gc_total_sized_buffers(PARROT_INTERP)>
 751
 752 Returns the total number of sized buffers that we are managing.
 753
 754 =cut
 755
 756 */
 757
 758 int
 759 Parrot_gc_total_sized_buffers(PARROT_INTERP)
 760 {
 761     ASSERT_ARGS(Parrot_gc_total_sized_buffers)
 762     return interp->gc_sys->get_gc_info(interp, TOTAL_BUFFERS);
 763 }
 764
 765 /*
 766
 767 =item C<int Parrot_gc_active_pmcs(PARROT_INTERP)>
 768
 769 Return the number of actively used PMCs.
 770
 771 =cut
 772
 773 */
 774
 775 int
 776 Parrot_gc_active_pmcs(PARROT_INTERP)
 777 {
 778     ASSERT_ARGS(Parrot_gc_active_pmcs)
 779     return interp->gc_sys->get_gc_info(interp, ACTIVE_PMCS);
 780 }
 781
 782 /*
 783
 784 =item C<int Parrot_gc_total_pmcs(PARROT_INTERP)>
 785
 786 Return the total number of PMCs that we are managing.
 787
 788 =cut
 789
 790 */
 791
 792 int
 793 Parrot_gc_total_pmcs(PARROT_INTERP)
 794 {
 795     ASSERT_ARGS(Parrot_gc_total_pmcs)
 796     return interp->gc_sys->get_gc_info(interp, TOTAL_PMCS);
 797 }
 798
 799 /*
 800
 801 =item C<size_t Parrot_gc_count_mark_runs(PARROT_INTERP)>
 802
 803 Return the number of mark runs the GC has performed.
 804
 805 =item C<size_t Parrot_gc_count_collect_runs(PARROT_INTERP)>
 806
 807 Return the number of collect runs the GC has performed.
 808
 809 =item C<size_t Parrot_gc_count_lazy_mark_runs(PARROT_INTERP)>
 810
 811 Return the number of lazy mark runs the GC has performed.
 812
 813 =item C<size_t Parrot_gc_total_memory_allocated(PARROT_INTERP)>
 814
 815 Return the total number of memory allocations made by the GC.
 816
 817 =item C<size_t Parrot_gc_headers_alloc_since_last_collect(PARROT_INTERP)>
 818
 819 Return the number of new headers allocated since the last collection run.
 820
 821 =item C<size_t Parrot_gc_mem_alloc_since_last_collect(PARROT_INTERP)>
 822
 823 Return the number of memory allocations made since the last collection run.
 824
 825 =item C<UINTVAL Parrot_gc_total_copied(PARROT_INTERP)>
 826
 827 =item C<UINTVAL Parrot_gc_impatient_pmcs(PARROT_INTERP)>
 828
 829 Returns the number of PMCs that are marked as needing timely destruction.
 830
 831 */
 832
 833 size_t
 834 Parrot_gc_count_mark_runs(PARROT_INTERP)
 835 {
 836     ASSERT_ARGS(Parrot_gc_count_mark_runs)
 837     return interp->gc_sys->get_gc_info(interp, GC_MARK_RUNS);
 838 }
 839
 840 size_t
 841 Parrot_gc_count_collect_runs(PARROT_INTERP)
 842 {
 843     ASSERT_ARGS(Parrot_gc_count_collect_runs)
 844     return interp->gc_sys->get_gc_info(interp, GC_COLLECT_RUNS);
 845 }
 846
 847 size_t
 848 Parrot_gc_count_lazy_mark_runs(PARROT_INTERP)
 849 {
 850     ASSERT_ARGS(Parrot_gc_count_lazy_mark_runs)
 851     return interp->gc_sys->get_gc_info(interp, GC_LAZY_MARK_RUNS);
 852 }
 853
 854 size_t
 855 Parrot_gc_total_memory_allocated(PARROT_INTERP)
 856 {
 857     ASSERT_ARGS(Parrot_gc_total_memory_allocated)
 858     return interp->gc_sys->get_gc_info(interp, TOTAL_MEM_ALLOC);
 859 }
 860
 861 size_t
 862 Parrot_gc_headers_alloc_since_last_collect(PARROT_INTERP)
 863 {
 864     ASSERT_ARGS(Parrot_gc_headers_alloc_since_last_collect)
 865     return interp->gc_sys->get_gc_info(interp, HEADER_ALLOCS_SINCE_COLLECT);
 866 }
 867
 868 size_t
 869 Parrot_gc_mem_alloc_since_last_collect(PARROT_INTERP)
 870 {
 871     ASSERT_ARGS(Parrot_gc_mem_alloc_since_last_collect)
 872     return interp->gc_sys->get_gc_info(interp, MEM_ALLOCS_SINCE_COLLECT);
 873 }
 874
 875 UINTVAL
 876 Parrot_gc_total_copied(PARROT_INTERP)
 877 {
 878     ASSERT_ARGS(Parrot_gc_total_copied)
 879     return interp->gc_sys->get_gc_info(interp, TOTAL_COPIED);
 880 }
 881
 882 UINTVAL
 883 Parrot_gc_impatient_pmcs(PARROT_INTERP)
 884 {
 885     ASSERT_ARGS(Parrot_gc_impatient_pmcs)
 886     return interp->gc_sys->get_gc_info(interp, IMPATIENT_PMCS);
 887 }
 888
 889 /*
 890
 891 =item C<void Parrot_block_GC_mark(PARROT_INTERP)>
 892
 893 Blocks the GC from performing its mark phase.
 894
 895 =item C<void Parrot_unblock_GC_mark(PARROT_INTERP)>
 896
 897 Unblocks the GC mark.
 898
 899 =item C<void Parrot_block_GC_sweep(PARROT_INTERP)>
 900
 901 Blocks the GC from performing its sweep phase.
 902
 903 =item C<void Parrot_unblock_GC_sweep(PARROT_INTERP)>
 904
 905 Unblocks GC sweep.
 906
 907 =item C<unsigned int Parrot_is_blocked_GC_mark(PARROT_INTERP)>
 908
 909 Determines if the GC mark is currently blocked.
 910
 911 =item C<unsigned int Parrot_is_blocked_GC_sweep(PARROT_INTERP)>
 912
 913 Determines if the GC sweep is currently blocked.
 914
 915 =item C<void Parrot_gc_completely_unblock(PARROT_INTERP)>
 916
 917 Completely unblock the GC mark and sweep. This is only used at interpreter
 918 destruction, using it anywhere else will cause problems.
 919
 920 =cut
 921
 922 */
 923
 924 PARROT_EXPORT
 925 void
 926 Parrot_block_GC_mark(PARROT_INTERP)
 927 {
 928     ASSERT_ARGS(Parrot_block_GC_mark)
 929     if (interp->gc_sys->block_mark)
 930         interp->gc_sys->block_mark(interp);
 931 }
 932
 933 PARROT_EXPORT
 934 void
 935 Parrot_unblock_GC_mark(PARROT_INTERP)
 936 {
 937     ASSERT_ARGS(Parrot_unblock_GC_mark)
 938     if (interp->gc_sys->unblock_mark)
 939         interp->gc_sys->unblock_mark(interp);
 940 }
 941
 942 PARROT_EXPORT
 943 void
 944 Parrot_block_GC_sweep(PARROT_INTERP)
 945 {
 946     ASSERT_ARGS(Parrot_block_GC_sweep)
 947     if (interp->gc_sys->block_sweep)
 948         interp->gc_sys->block_sweep(interp);
 949 }
 950
 951 PARROT_EXPORT
 952 void
 953 Parrot_unblock_GC_sweep(PARROT_INTERP)
 954 {
 955     ASSERT_ARGS(Parrot_unblock_GC_sweep)
 956     if (interp->gc_sys->unblock_sweep)
 957         interp->gc_sys->unblock_sweep(interp);
 958 }
 959
 960 PARROT_EXPORT
 961 unsigned int
 962 Parrot_is_blocked_GC_mark(PARROT_INTERP)
 963 {
 964     ASSERT_ARGS(Parrot_is_blocked_GC_mark)
 965     if (interp->gc_sys->is_blocked_mark)
 966         return interp->gc_sys->is_blocked_mark(interp);
 967     else
 968         return 0;
 969 }
 970
 971 PARROT_EXPORT
 972 unsigned int
 973 Parrot_is_blocked_GC_sweep(PARROT_INTERP)
 974 {
 975     ASSERT_ARGS(Parrot_is_blocked_GC_sweep)
 976     if (interp->gc_sys->is_blocked_sweep)
 977         return interp->gc_sys->is_blocked_mark(interp);
 978     else
 979         return 0;
 980 }
 981
 982 void
 983 Parrot_gc_completely_unblock(PARROT_INTERP)
 984 {
 985     ASSERT_ARGS(Parrot_gc_completely_unblock)
 986     while (Parrot_is_blocked_GC_mark(interp))
 987            Parrot_unblock_GC_mark(interp);
 988     while (Parrot_is_blocked_GC_sweep(interp))
 989            Parrot_unblock_GC_sweep(interp);
 990 }
 991
 992 /*
 993
 994 =item C<void Parrot_gc_pmc_needs_early_collection(PARROT_INTERP, PMC *pmc)>
 995
 996 Mark a PMC as needing timely destruction
 997
 998 =cut
 999
1000 */
1001
1002 void
1003 Parrot_gc_pmc_needs_early_collection(PARROT_INTERP, ARGMOD(PMC *pmc))
1004 {
1005     ASSERT_ARGS(Parrot_gc_pmc_needs_early_collection)
1006     if (interp->gc_sys->pmc_needs_early_collection)
1007         interp->gc_sys->pmc_needs_early_collection(interp, pmc);
1008 }
1009
1010 /*
1011
1012 =item C<STRING * Parrot_gc_sys_name(PARROT_INTERP)>
1013
1014 Retrieve the name of the currently active GC system.
1015
1016 =cut
1017
1018 */
1019
1020 PARROT_CANNOT_RETURN_NULL
1021 STRING *
1022 Parrot_gc_sys_name(PARROT_INTERP)
1023 {
1024     ASSERT_ARGS(Parrot_gc_sys_name)
1025     STRING *name = NULL;
1026     switch (interp->gc_sys->sys_type) {
1027         case MS:
1028             name = Parrot_str_new(interp, "ms", 2);
1029             break;
1030         case INF:
1031             name = Parrot_str_new(interp, "inf", 3);
1032             break;
1033         default:
1034             name = Parrot_str_new(interp, "unknown", 7);
1035             break;
1036     }
1037     PARROT_ASSERT(name != NULL);
1038     return name;
1039 }
1040
1041 /*
1042
1043 =back
1044
1045 =head1 SEE ALSO
1046
1047 F<include/parrot/gc_api.h>, F<src/gc/system.c> and F<docs/pdds/pdd09_gc.pod>.
1048
1049 =head1 HISTORY
1050
1051 Initial version by Mike Lambert on 2002.05.27.
1052
1053 =cut
1054
1055 */
1056
1057 /*
1058  * Local variables:
1059  *   c-file-style: "parrot"
1060  * End:
1061  * vim: expandtab shiftwidth=4:
1062  */