graal-compiler: src/share/vm/gc_implementation/g1/concurrentMark.hpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.hpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	988bf00cc564
children	442f942757c0

comparison

equal deleted inserted replaced

-:81e878c53615
+:8a5ea0a9ccc4
 HeapWord* volatile      _finger;  // the global finger, region aligned,
 // always points to the end of the
 // last claimed region
 // marking tasks
-uint                    _max_task_num; // maximum task number
+uint                    _max_worker_id;// maximum worker id
 uint                    _active_tasks; // task num currently active
-CMTask**                _tasks;        // task queue array (max_task_num len)
+CMTask**                _tasks;        // task queue array (max_worker_id len)
 CMTaskQueueSet*         _task_queues;  // task queue set
 ParallelTaskTerminator  _terminator;   // for termination
 // Two sync barriers that are used to synchronise tasks when an
 // overflow occurs. The algorithm is the following. All tasks enter
 bool                    concurrent()    { return _concurrent; }
 uint                    active_tasks()  { return _active_tasks; }
 ParallelTaskTerminator* terminator()    { return &_terminator; }
 // It claims the next available region to be scanned by a marking
-// task. It might return NULL if the next region is empty or we have
+// task/thread. It might return NULL if the next region is empty or
-// run out of regions. In the latter case, out_of_regions()
+// we have run out of regions. In the latter case, out_of_regions()
 // determines whether we've really run out of regions or the task
-// should call claim_region() again.  This might seem a bit
+// should call claim_region() again. This might seem a bit
 // awkward. Originally, the code was written so that claim_region()
 // either successfully returned with a non-empty region or there
 // were no more regions to be claimed. The problem with this was
 // that, in certain circumstances, it iterated over large chunks of
 // the heap finding only empty regions and, while it was working, it
 // was preventing the calling task to call its regular clock
 // method. So, this way, each task will spend very little time in
 // claim_region() and is allowed to call the regular clock method
 // frequently.
-HeapRegion* claim_region(int task);
+HeapRegion* claim_region(uint worker_id);
 // It determines whether we've run out of regions to scan.
 bool        out_of_regions() { return _finger == _heap_end; }
 // Returns the task with the given id
 bool restart_for_overflow()    { return _restart_for_overflow; }
 bool has_aborted()             { return _has_aborted; }
 // Methods to enter the two overflow sync barriers
-void enter_first_sync_barrier(int task_num);
+void enter_first_sync_barrier(uint worker_id);
-void enter_second_sync_barrier(int task_num);
+void enter_second_sync_barrier(uint worker_id);
 ForceOverflowSettings* force_overflow_conc() {
 return &_force_overflow_conc;
 }
 _accum_task_vtime[i] += vtime;
 }
 double all_task_accum_vtime() {
 double ret = 0.0;
-for (int i = 0; i < (int)_max_task_num; ++i)
+for (uint i = 0; i < _max_worker_id; ++i)
 ret += _accum_task_vtime[i];
 return ret;
 }
 // Attempts to steal an object from the task queues of other tasks
-bool try_stealing(int task_num, int* hash_seed, oop& obj) {
+bool try_stealing(uint worker_id, int* hash_seed, oop& obj) {
-return _task_queues->steal(task_num, hash_seed, obj);
+return _task_queues->steal(worker_id, hash_seed, obj);
 }
 ConcurrentMark(ReservedSpace rs, uint max_regions);
 ~ConcurrentMark();
 return _heap_bottom_card_num;
 }
 // Returns the card bitmap for a given task or worker id.
 BitMap* count_card_bitmap_for(uint worker_id) {
-assert(0 <= worker_id && worker_id < _max_task_num, "oob");
+assert(0 <= worker_id && worker_id < _max_worker_id, "oob");
 assert(_count_card_bitmaps != NULL, "uninitialized");
 BitMap* task_card_bm = &_count_card_bitmaps[worker_id];
 assert(task_card_bm->size() == _card_bm.size(), "size mismatch");
 return task_card_bm;
 }
 // Returns the array containing the marked bytes for each region,
 // for the given worker or task id.
 size_t* count_marked_bytes_array_for(uint worker_id) {
-assert(0 <= worker_id && worker_id < _max_task_num, "oob");
+assert(0 <= worker_id && worker_id < _max_worker_id, "oob");
 assert(_count_marked_bytes != NULL, "uninitialized");
 size_t* marked_bytes_array = _count_marked_bytes[worker_id];
 assert(marked_bytes_array != NULL, "uninitialized");
 return marked_bytes_array;
 }
 // how many entries will be transferred between global stack and
 // local queues
 global_stack_transfer_size    = 16
 };
-int                         _task_id;
+uint                        _worker_id;
 G1CollectedHeap*            _g1h;
 ConcurrentMark*             _cm;
 CMBitMap*                   _nextMarkBitMap;
 // the task queue of this task
 CMTaskQueue*                _task_queue;
 }
 void record_end_time() {
 _elapsed_time_ms = os::elapsedTime() * 1000.0 - _elapsed_time_ms;
 }
-// returns the task ID
+// returns the worker ID associated with this task.
-int task_id() { return _task_id; }
+uint worker_id() { return _worker_id; }
 // From TerminatorTerminator. It determines whether this task should
 // exit the termination protocol after it's entered it.
 virtual bool should_exit_termination();
 inline void move_finger_to(HeapWord* new_finger) {
 assert(new_finger >= _finger && new_finger < _region_limit, "invariant");
 _finger = new_finger;
 }
-CMTask(int task_num, ConcurrentMark *cm,
+CMTask(uint worker_id, ConcurrentMark *cm,
 size_t* marked_bytes, BitMap* card_bm,
 CMTaskQueue* task_queue, CMTaskQueueSet* task_queues);
 // it prints statistics associated with this task
 void print_stats();

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/concurrentMark.hpp @ 6862:8a5ea0a9ccc4