src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp

Print this page
rev 5891 : [mq]: hideDoCodeRoots


 816 
 817   // Abandon the current collection set without recording policy
 818   // statistics or updating free lists.
 819   void abandon_collection_set(HeapRegion* cs_head);
 820 
 821   // Applies "scan_non_heap_roots" to roots outside the heap,
 822   // "scan_rs" to roots inside the heap (having done "set_region" to
 823   // indicate the region in which the root resides),
 824   // and does "scan_metadata" If "scan_rs" is
 825   // NULL, then this step is skipped.  The "worker_i"
 826   // param is for use with parallel roots processing, and should be
 827   // the "i" of the calling parallel worker thread's work(i) function.
 828   // In the sequential case this param will be ignored.
 829   void g1_process_strong_roots(bool is_scavenging,
 830                                ScanningOption so,
 831                                OopClosure* scan_non_heap_roots,
 832                                OopsInHeapRegionClosure* scan_rs,
 833                                G1KlassScanClosure* scan_klasses,
 834                                int worker_i);
 835 
 836   // Apply "blk" to all the weak roots of the system.  These include
 837   // JNI weak roots, the code cache, system dictionary, symbol table,
 838   // string table, and referents of reachable weak refs.
 839   void g1_process_weak_roots(OopClosure* root_closure);
 840 
 841   // Frees a non-humongous region by initializing its contents and
 842   // adding it to the free list that's passed as a parameter (this is
 843   // usually a local list which will be appended to the master free
 844   // list later). The used bytes of freed regions are accumulated in
 845   // pre_used. If par is true, the region's RSet will not be freed
 846   // up. The assumption is that this will be done later.
 847   void free_region(HeapRegion* hr,
 848                    size_t* pre_used,
 849                    FreeRegionList* free_list,
 850                    bool par);
 851 
 852   // Frees a humongous region by collapsing it into individual regions
 853   // and calling free_region() for each of them. The freed regions
 854   // will be added to the free list that's passed as a parameter (this
 855   // is usually a local list which will be appended to the master free
 856   // list later). The used bytes of freed regions are accumulated in
 857   // pre_used. If par is true, the region's RSet will not be freed
 858   // up. The assumption is that this will be done later.
 859   void free_humongous_region(HeapRegion* hr,
 860                              size_t* pre_used,




 816 
 817   // Abandon the current collection set without recording policy
 818   // statistics or updating free lists.
 819   void abandon_collection_set(HeapRegion* cs_head);
 820 
 821   // Applies "scan_non_heap_roots" to roots outside the heap,
 822   // "scan_rs" to roots inside the heap (having done "set_region" to
 823   // indicate the region in which the root resides),
 824   // and does "scan_metadata" If "scan_rs" is
 825   // NULL, then this step is skipped.  The "worker_i"
 826   // param is for use with parallel roots processing, and should be
 827   // the "i" of the calling parallel worker thread's work(i) function.
 828   // In the sequential case this param will be ignored.
 829   void g1_process_strong_roots(bool is_scavenging,
 830                                ScanningOption so,
 831                                OopClosure* scan_non_heap_roots,
 832                                OopsInHeapRegionClosure* scan_rs,
 833                                G1KlassScanClosure* scan_klasses,
 834                                int worker_i);
 835 





 836   // Frees a non-humongous region by initializing its contents and
 837   // adding it to the free list that's passed as a parameter (this is
 838   // usually a local list which will be appended to the master free
 839   // list later). The used bytes of freed regions are accumulated in
 840   // pre_used. If par is true, the region's RSet will not be freed
 841   // up. The assumption is that this will be done later.
 842   void free_region(HeapRegion* hr,
 843                    size_t* pre_used,
 844                    FreeRegionList* free_list,
 845                    bool par);
 846 
 847   // Frees a humongous region by collapsing it into individual regions
 848   // and calling free_region() for each of them. The freed regions
 849   // will be added to the free list that's passed as a parameter (this
 850   // is usually a local list which will be appended to the master free
 851   // list later). The used bytes of freed regions are accumulated in
 852   // pre_used. If par is true, the region's RSet will not be freed
 853   // up. The assumption is that this will be done later.
 854   void free_humongous_region(HeapRegion* hr,
 855                              size_t* pre_used,