void InitBags(UInt initial_size, Bag * stack_bottom, UInt stack_align) { UInt i; /* loop variable */ /* install the marking functions */ for (i = 0; i < NUM_TYPES; i++) { TabMarkTypeBags[i] = -1; } #ifndef DISABLE_GC #ifdef HPCGAP if (!getenv("GC_MARKERS")) { /* The Boehm GC does not have an API to set the number of * markers for the parallel mark and sweep implementation, * so we use the documented environment variable GC_MARKERS * instead. However, we do not override it if it's already * set. */ static char marker_env_str[32]; unsigned num_markers = 2; if (!SyNumGCThreads) SyNumGCThreads = SyNumProcessors; if (SyNumGCThreads) { if (SyNumGCThreads <= MAX_GC_THREADS) num_markers = (unsigned)SyNumProcessors; else num_markers = MAX_GC_THREADS; } sprintf(marker_env_str, "GC_MARKERS=%u", num_markers); putenv(marker_env_str); } #endif GC_set_all_interior_pointers(0); GC_init(); GC_set_free_space_divisor(1); TLAllocatorInit(); GC_register_displacement(0); GC_register_displacement(sizeof(BagHeader)); initial_size *= 1024; if (GC_get_heap_size() < initial_size) GC_expand_hp(initial_size - GC_get_heap_size()); if (SyStorKill) GC_set_max_heap_size(SyStorKill * 1024); #ifdef HPCGAP AddGCRoots(); CreateMainRegion(); #else void * p = ActiveGAPState(); GC_add_roots(p, (char *)p + sizeof(GAPState)); #endif for (i = 0; i <= MAX_GC_PREFIX_DESC; i++) { BuildPrefixGCDescriptor(i); /* This is necessary to initialize some internal structures * in the garbage collector: */ GC_generic_malloc(sizeof(BagHeader) + i * sizeof(Bag), GCMKind[i]); } #endif /* DISABLE_GC */ }
static void on_gc_notification (GCEventType event) { MonoGCEvent e = (MonoGCEvent)event; switch (e) { case MONO_GC_EVENT_PRE_STOP_WORLD: MONO_GC_WORLD_STOP_BEGIN (); mono_thread_info_suspend_lock (); break; case MONO_GC_EVENT_POST_STOP_WORLD: MONO_GC_WORLD_STOP_END (); break; case MONO_GC_EVENT_PRE_START_WORLD: MONO_GC_WORLD_RESTART_BEGIN (1); break; case MONO_GC_EVENT_POST_START_WORLD: MONO_GC_WORLD_RESTART_END (1); mono_thread_info_suspend_unlock (); break; case MONO_GC_EVENT_START: MONO_GC_BEGIN (1); #ifndef DISABLE_PERFCOUNTERS if (mono_perfcounters) mono_perfcounters->gc_collections0++; #endif gc_stats.major_gc_count ++; gc_start_time = mono_100ns_ticks (); break; case MONO_GC_EVENT_END: MONO_GC_END (1); #if defined(ENABLE_DTRACE) && defined(__sun__) /* This works around a dtrace -G problem on Solaris. Limit its actual use to when the probe is enabled. */ if (MONO_GC_END_ENABLED ()) sleep(0); #endif #ifndef DISABLE_PERFCOUNTERS if (mono_perfcounters) { guint64 heap_size = GC_get_heap_size (); guint64 used_size = heap_size - GC_get_free_bytes (); mono_perfcounters->gc_total_bytes = used_size; mono_perfcounters->gc_committed_bytes = heap_size; mono_perfcounters->gc_reserved_bytes = heap_size; mono_perfcounters->gc_gen0size = heap_size; } #endif gc_stats.major_gc_time_usecs += (mono_100ns_ticks () - gc_start_time) / 10; mono_trace_message (MONO_TRACE_GC, "gc took %d usecs", (mono_100ns_ticks () - gc_start_time) / 10); break; } mono_profiler_gc_event (e, 0); }
GC_USER_FUNC void ml_print_plot_data (void) { #if defined(GC_CHERI) unsigned long long heapsyinit = GC_THREAD_LOCAL_HEAP_SIZE, heapsycurr = GC_cheri_getlen(GC_state.thread_local_region.tospace), heapsymaxb = GC_state.thread_local_region.max_grow_size_before_collection, heapsymaxa = GC_state.thread_local_region.max_grow_size_after_collection; printf("[plotdata] # heap size: (young generation) I=%llu B=%llu A=%llu F=%llu\n", heapsyinit, heapsymaxb, heapsymaxa, heapsycurr); #ifdef GC_GENERATIONAL unsigned long long heapsoinit = GC_OLD_GENERATION_SEMISPACE_SIZE, heapsocurr = GC_cheri_getlen(GC_state.old_generation.tospace), heapsomaxb = GC_state.old_generation.max_grow_size_before_collection, heapsomaxa = GC_state.old_generation.max_grow_size_after_collection; printf("[plotdata] # heap size: (old generation) I=%llu B=%llu A=%llu F=%llu\n", heapsoinit, heapsomaxb, heapsomaxa, heapsocurr); #endif // GC_GENERATIONAL #elif defined(GC_BOEHM) printf("[plotdata] # Boehm heap size: %llu\n", (unsigned long long) GC_get_heap_size()); #endif }
/* Cleanup */ void cleanup_main(void *data) { ScmVM *vm = Scm_VM(); if (profiling_mode) { Scm_ProfilerStop(); Scm_EvalCString("(profiler-show)", SCM_OBJ(Scm_GaucheModule()), NULL); /* ignore errors */ } /* EXPERIMENTAL */ if (stats_mode) { fprintf(stderr, "\n;; Statistics (*: main thread only):\n"); fprintf(stderr, ";; GC: %zubytes heap, %zubytes allocated\n", GC_get_heap_size(), GC_get_total_bytes()); fprintf(stderr, ";; stack overflow*: %ldtimes, %.2fms total/%.2fms avg\n", vm->stat.sovCount, vm->stat.sovTime/1000.0, (vm->stat.sovCount > 0? (double)(vm->stat.sovTime/vm->stat.sovCount)/1000.0 : 0.0)); } /* EXPERIMENTAL */ if (SCM_VM_RUNTIME_FLAG_IS_SET(vm, SCM_COLLECT_LOAD_STATS)) { Scm_Eval(SCM_LIST2(SCM_INTERN("profiler-show-load-stats"), SCM_LIST2(SCM_INTERN("quote"), vm->stat.loadStat)), SCM_OBJ(Scm_GaucheModule()), NULL); /* ignore errors */ } }
static void on_gc_notification (GCEventType event) { MonoGCEvent e = (MonoGCEvent)event; if (e == MONO_GC_EVENT_PRE_STOP_WORLD) mono_thread_info_suspend_lock (); else if (e == MONO_GC_EVENT_POST_START_WORLD) mono_thread_info_suspend_unlock (); if (e == MONO_GC_EVENT_START) { if (mono_perfcounters) mono_perfcounters->gc_collections0++; mono_stats.major_gc_count ++; gc_start_time = mono_100ns_ticks (); } else if (e == MONO_GC_EVENT_END) { if (mono_perfcounters) { guint64 heap_size = GC_get_heap_size (); guint64 used_size = heap_size - GC_get_free_bytes (); mono_perfcounters->gc_total_bytes = used_size; mono_perfcounters->gc_committed_bytes = heap_size; mono_perfcounters->gc_reserved_bytes = heap_size; mono_perfcounters->gc_gen0size = heap_size; } mono_stats.major_gc_time_usecs += (mono_100ns_ticks () - gc_start_time) / 10; mono_trace_message (MONO_TRACE_GC, "gc took %d usecs", (mono_100ns_ticks () - gc_start_time) / 10); } mono_profiler_gc_event (e, 0); }
jboolean initGC(Options* options) { GC_set_no_dls(1); GC_set_java_finalization(1); GC_INIT(); if (options->maxHeapSize > 0) { GC_set_max_heap_size(options->maxHeapSize); } if (options->initialHeapSize > 0) { size_t now = GC_get_heap_size(); if (options->initialHeapSize > now) { GC_expand_hp(options->initialHeapSize - now); } } objectGCKind = GC_new_kind(GC_new_free_list(), GC_MAKE_PROC(GC_new_proc(markObject), 0), 0, 1); largeArrayGCKind = GC_new_kind(GC_new_free_list(), GC_DS_LENGTH, 1, 1); atomicObjectGCKind = GC_new_kind(GC_new_free_list(), GC_DS_LENGTH, 0, 1); referentEntryGCKind = gcNewDirectBitmapKind(REFERENT_ENTRY_GC_BITMAP); if (rvmInitMutex(&referentsLock) != 0) { return FALSE; } if (rvmInitMutex(&gcRootsLock) != 0) { return FALSE; } GC_set_warn_proc(gcWarnProc); return TRUE; }
static void on_gc_heap_resize (size_t new_size) { guint64 heap_size = GC_get_heap_size (); mono_perfcounters->gc_committed_bytes = heap_size; mono_perfcounters->gc_reserved_bytes = heap_size; mono_perfcounters->gc_gen0size = heap_size; mono_profiler_gc_heap_resize (new_size); }
JAVA_LONG java_lang_Runtime_totalMemory__(JAVA_OBJECT me) { //XMLVM_BEGIN_NATIVE[java_lang_Runtime_totalMemory__] #ifndef XMLVM_NO_GC return GC_get_heap_size(); #else return 0L; #endif //XMLVM_END_NATIVE }
void epicMemInfo() { GC_gcollect(); int heap = GC_get_heap_size(); int free = GC_get_free_bytes(); int total = GC_get_total_bytes(); printf("Heap size %d\n", heap); printf("Heap used %d\n", heap-free); printf("Total allocations %d\n", total); }
GC_USER_FUNC void ml_print_gc_stats (void) { #if defined(GC_CHERI) GC_debug_print_region_stats(&GC_state.thread_local_region); #ifdef GC_GENERATIONAL GC_debug_print_region_stats(&GC_state.old_generation); #endif // GC_GENERATIONAL #elif defined(GC_BOEHM) printf("Boehm heap size: %llu\n", (unsigned long long) GC_get_heap_size()); #endif // GC selector }
static void on_gc_heap_resize (size_t new_size) { guint64 heap_size = GC_get_heap_size (); #ifndef DISABLE_PERFCOUNTERS if (mono_perfcounters) { mono_perfcounters->gc_committed_bytes = heap_size; mono_perfcounters->gc_reserved_bytes = heap_size; mono_perfcounters->gc_gen0size = heap_size; } #endif mono_profiler_gc_heap_resize (new_size); }
int main() { int i; GC_INIT(); /* Optional on Linux/X86; see below. */ for (i = 0; i < 10000000; ++i) { int **p = (int **) GC_MALLOC(sizeof(int *)); int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int)); assert(*p == 0); *p = (int *) GC_REALLOC(q, 2 * sizeof(int)); if (i % 100000 == 0) printf("Heap size = %d\n", GC_get_heap_size()); } return 0; }
static void on_gc_notification (GCEventType event) { if (event == MONO_GC_EVENT_START) { mono_perfcounters->gc_collections0++; mono_stats.major_gc_count ++; gc_start_time = mono_100ns_ticks (); } else if (event == MONO_GC_EVENT_END) { guint64 heap_size = GC_get_heap_size (); guint64 used_size = heap_size - GC_get_free_bytes (); mono_perfcounters->gc_total_bytes = used_size; mono_perfcounters->gc_committed_bytes = heap_size; mono_perfcounters->gc_reserved_bytes = heap_size; mono_perfcounters->gc_gen0size = heap_size; mono_stats.major_gc_time_usecs += (mono_100ns_ticks () - gc_start_time) / 10; mono_trace_message (MONO_TRACE_GC, "gc took %d usecs", (mono_100ns_ticks () - gc_start_time) / 10); } mono_profiler_gc_event ((MonoGCEvent) event, 0); }
jboolean initGC(Options* options) { GC_INIT(); GC_set_java_finalization(1); if (options->maxHeapSize > 0) { GC_set_max_heap_size(options->maxHeapSize); } if (options->initialHeapSize > 0) { size_t now = GC_get_heap_size(); if (options->initialHeapSize > now) { GC_expand_hp(options->initialHeapSize - now); } } object_gc_kind = GC_new_kind(GC_new_free_list(), GC_MAKE_PROC(GC_new_proc(markObject), 0), 0, 1); if (rvmInitMutex(&referentsLock) != 0) { return FALSE; } return TRUE; }
int64_t sysGetHeapSize() { return GC_get_heap_size(); }
GC_USER_FUNC int main (int argc, char ** argv) { #ifdef MEMWATCH mwInit(); mwDoFlush(1); #endif // MEMWATCH ML_START_TIMING(main_time); GC_init(); //ml_print_gc_stats(); printf("Compiled for " #if defined(GC_CHERI) "GC_CHERI" #elif defined(GC_BOEHM) "GC_BOEHM" #elif defined(GC_NONE) "GC_NONE" #elif defined(GC_NOCAP) "GC_NOCAP" #else #error "Define one of GC_CHERI, GC_BOEHM, GC_NONE." #endif // GC_CHERI, GC_BOEHM, GC_NONE " at %s\n", __TIME__ " " __DATE__); //GC_CAP const char * filename = GC_cheri_ptr("ml-tmp", sizeof("ml-tmp")); //lex_read_file(filename); //const char str[] = "(fn x . ((fn x . x) 3) + x) 2"; //const char str[] = "fn f . (fn g. (f (fn a . (g g) a))) (fn g. (f (fn a . (g g) a)))"; //const char str[] = //"((fn f . fn n . if n then n * f (n-1) else 1) (fn n . n)) 5"; // factorial: //const char str[] = // "((fn f . (fn g. (f (fn a . (g g) a))) (fn g. (f (fn a . (g g) a)))) (fn f . fn n . if n then n * f (n-1) else 1)) 6"; // for the benchmark: if (argc < 2) { printf("Need a program argument\n"); return 1; } if (argc < 3) { printf("Need a number argument\n"); return 1; } printf("Program should be evaluating something to do with the number %s\n", argv[2]); int num = atoi(argv[2]); #ifdef GC_CHERI gc_cheri_grow_heap(num); #endif #ifdef GC_BOEHM GC_set_max_heap_size(num >= 1024 ? 350000*(num/1024) : num >= 256 ? 200000 : 65536); #endif /*const char str[] = "((fn f . (fn g. (f (fn a . (g g) a))) (fn g. (f (fn f . (g g) f)))) (fn f . fn n . if n then n + f (n-1) else 1)) "; GC_CAP char * str2 = ml_malloc(sizeof(str)+strlen(argv[1])); cmemcpy(str2, GC_cheri_ptr(str, sizeof(str)), sizeof(str)); cmemcpy(str2+sizeof(str)-1, GC_cheri_ptr(argv[1], strlen(argv[1]+1)), strlen(argv[1]+1)); */ GC_CAP const char * str2 = GC_cheri_ptr(argv[1], strlen(argv[1])+1); unsigned long long before = ml_time(); lex_read_string(str2); printf("program: %s\n\n", (void*)(str2)); /*size_t i; for (i=0; i<lex_state.max; i++) { putchar(((char*)lex_state.file)[i]); } GC_CAP token_t * t; t = lex(); while (t->type != TKEOF) { printf("[%d] (tag=%d alloc=%d) %s\n", ((token_t*)t)->type, (int) GC_cheri_gettag(((token_t*)t)->str), (int) GC_IS_GC_ALLOCATED(((token_t*)t)->str), (char*) ((token_t*)t)->str); GC_malloc(5000); t = lex(); } printf("Finished\n"); return 0;*/ parse_init(); GC_CAP expr_t * expr = GC_INVALID_PTR(); GC_STORE_CAP(expr, parse()); printf("AST:\n"); print_ast(expr); printf("\nDone printing AST\n"); /*printf("collecting loads\n"); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); ml_collect(); printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~done collecting loads\n"); GC_debug_print_region_stats(&GC_state.thread_local_region);*/ GC_CAP val_t * val = GC_INVALID_PTR(); int i; for (i=0; i<10; i++) { GC_STORE_CAP(val, eval(expr, GC_INVALID_PTR())); } unsigned long long after = ml_time(); unsigned long long diff = after - before; printf("eval: "); if (!PTR_VALID(val)) printf("(invalid"); else print_val(val); printf("\n\n"); printf("[plotdata] %s %llu\n", argv[2], (unsigned long long) diff); #ifdef GC_CHERI printf("(young) heap size:\n"); printf("[altplotdata] %s %llu\n", argv[2], (unsigned long long) (GC_cheri_getlen(GC_state.thread_local_region.tospace))); #ifdef GC_GENERATIONAL printf("old heap size:\n"); printf("[altplotdataold] %s %llu\n", argv[2], (unsigned long long) (GC_cheri_getlen(GC_state.old_generation.tospace))); #endif // GC_GENERATIONAL #endif // GC_CHERI #ifdef GC_BOEHM printf("[altplotdata] %s %llu\n", argv[2], (unsigned long long) GC_get_heap_size()); #endif // GC_BOEHM ML_STOP_TIMING(main_time, "main()"); ml_print_gc_stats(); ml_print_plot_data(); #ifdef MEMWATCH mwTerm(); #endif // MEMWATCH return 0; }
EXTERN void neko_gc_stats( int *heap, int *free ) { *heap = (int)GC_get_heap_size(); *free = (int)GC_get_free_bytes(); }
/** * mono_gc_get_heap_size: * * Get the amount of memory used by the garbage collector. * * Returns: the size of the heap in bytes */ int64_t mono_gc_get_heap_size (void) { return GC_get_heap_size (); }
/** * mono_gc_get_used_size: * * Get the approximate amount of memory used by managed objects. * * Returns: the amount of memory used in bytes */ int64_t mono_gc_get_used_size (void) { return GC_get_heap_size () - GC_get_free_bytes (); }
long ILGCGetHeapSize(void) { return (long)GC_get_heap_size(); }
int main() { Node root; Node longLivedTree; Node tempTree; long tStart, tFinish; long tElapsed; int i, d; double *array; #ifdef GC // GC_full_freq = 30; // GC_free_space_divisor = 16; // GC_enable_incremental(); #endif printf("Garbage Collector Test\n"); printf(" Live storage will peak at %d bytes.\n\n", 2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) + sizeof(double) * kArraySize); printf(" Stretching memory with a binary tree of depth %d\n", kStretchTreeDepth); PrintDiagnostics(); # ifdef PROFIL init_profiling(); # endif tStart = currentTime(); // Stretch the memory space quickly tempTree = MakeTree(kStretchTreeDepth); # ifndef GC destroy_Node(tempTree); # endif tempTree = 0; // Create a long lived object printf(" Creating a long-lived binary tree of depth %d\n", kLongLivedTreeDepth); # ifndef GC longLivedTree = calloc(1, sizeof(Node0)); # else longLivedTree = GC_NEW(Node0); # endif Populate(kLongLivedTreeDepth, longLivedTree); ggggc_collectFull(); // Create long-lived array, filling half of it printf(" Creating a long-lived array of %d doubles\n", kArraySize); # ifndef GC array = malloc(kArraySize * sizeof(double)); # else # ifndef NO_PTRFREE array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize); # else array = GC_MALLOC(sizeof(double) * kArraySize); # endif # endif ggggc_collectFull(); for (i = 0; i < kArraySize/2; ++i) { array[i] = 1.0/i; } PrintDiagnostics(); for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) { TimeConstruction(d); } if (longLivedTree == 0 || array[1000] != 1.0/1000) fprintf(stderr, "Failed\n"); // fake reference to LongLivedTree // and array // to keep them from being optimized away tFinish = currentTime(); tElapsed = elapsedTime(tFinish-tStart); PrintDiagnostics(); printf("Completed in %d msec\n", tElapsed); # ifdef GC printf("Completed %d collections\n", GC_gc_no); printf("Heap size is %d\n", GC_get_heap_size()); # endif # ifdef PROFIL dump_profile(); # endif }
void main() { Node root; Node longLivedTree; Node tempTree; long tStart, tFinish; long tElapsed; #ifdef GC // GC_full_freq = 30; GC_enable_incremental(); #endif cout << "Garbage Collector Test" << endl; cout << " Live storage will peak at " << 2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) + sizeof(double) * kArraySize << " bytes." << endl << endl; cout << " Stretching memory with a binary tree of depth " << kStretchTreeDepth << endl; PrintDiagnostics(); tStart = currentTime(); // Stretch the memory space quickly tempTree = MakeTree(kStretchTreeDepth); # ifndef GC delete tempTree; # endif tempTree = 0; // Create a long lived object cout << " Creating a long-lived binary tree of depth " << kLongLivedTreeDepth << endl; # ifndef GC longLivedTree = new Node0(); # else longLivedTree = new (GC_NEW(Node0)) Node0(); # endif Populate(kLongLivedTreeDepth, longLivedTree); // Create long-lived array, filling half of it cout << " Creating a long-lived array of " << kArraySize << " doubles" << endl; # ifndef GC double *array = new double[kArraySize]; # else double *array = (double *) GC_MALLOC_ATOMIC(sizeof(double) * kArraySize); # endif for (int i = 0; i < kArraySize/2; ++i) { array[i] = 1.0/i; } PrintDiagnostics(); for (int d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) { TimeConstruction(d); } if (longLivedTree == 0 || array[1000] != 1.0/1000) cout << "Failed" << endl; // fake reference to LongLivedTree // and array // to keep them from being optimized away tFinish = currentTime(); tElapsed = elapsedTime(tFinish-tStart); PrintDiagnostics(); cout << "Completed in " << tElapsed << " msec" << endl; # ifdef GC cout << "Completed " << GC_gc_no << " collections" <<endl; cout << "Heap size is " << GC_get_heap_size() << endl; # endif }