graal-jvmci-8: src/share/vm/utilities/workgroup.hpp comparison

comparison src/share/vm/utilities/workgroup.hpp @ 4728:441e946dc1af

7121618: Change type of number of GC workers to unsigned int. Summary: Change variables representing the number of GC workers to uint from int and size_t. Change the parameter in work(int i) to work(uint worker_id). Reviewed-by: brutisso, tonyp

author	jmasa
date	Wed, 14 Dec 2011 13:34:57 -0800
parents	bca17e38de00
children	d2a62e0f25eb

comparison

equal deleted inserted replaced

-:67fdcb391461
+:441e946dc1af
 // You subclass this to supply your own work() method
 class AbstractGangTask VALUE_OBJ_CLASS_SPEC {
 public:
 // The abstract work method.
 // The argument tells you which member of the gang you are.
-virtual void work(int i) = 0;
+virtual void work(uint worker_id) = 0;
 // This method configures the task for proper termination.
 // Some tasks do not have any requirements on termination
 // and may inherit this method that does nothing.  Some
 // tasks do some coordination on termination and override
 const char* _name;
 // The monitor which protects these data,
 // and notifies of changes in it.
 Monitor*  _monitor;
 // The count of the number of workers in the gang.
-int _total_workers;
+uint _total_workers;
 // Whether the workers should terminate.
 bool _terminate;
 // The array of worker threads for this gang.
 // This is only needed for cleaning up.
 GangWorker** _gang_workers;
 // The task for this gang.
 AbstractGangTask* _task;
 // A sequence number for the current task.
 int _sequence_number;
 // The number of started workers.
-int _started_workers;
+uint _started_workers;
 // The number of finished workers.
-int _finished_workers;
+uint _finished_workers;
 public:
 // Accessors for fields
 Monitor* monitor() const {
 return _monitor;
 }
-int total_workers() const {
+uint total_workers() const {
 return _total_workers;
 }
-virtual int active_workers() const {
+virtual uint active_workers() const {
 return _total_workers;
 }
 bool terminate() const {
 return _terminate;
 }
 return _task;
 }
 int sequence_number() const {
 return _sequence_number;
 }
-int started_workers() const {
+uint started_workers() const {
 return _started_workers;
 }
-int finished_workers() const {
+uint finished_workers() const {
 return _finished_workers;
 }
 bool are_GC_task_threads() const {
 return _are_GC_task_threads;
 }
 // Predicates.
 bool is_idle() const {
 return (task() == NULL);
 }
 // Return the Ith gang worker.
-GangWorker* gang_worker(int i) const;
+GangWorker* gang_worker(uint i) const;
 void threads_do(ThreadClosure* tc) const;
 // Printing
 void print_worker_threads_on(outputStream *st) const;
 // Class WorkGang:
 class WorkGang: public AbstractWorkGang {
 public:
 // Constructor
-WorkGang(const char* name, int workers,
+WorkGang(const char* name, uint workers,
 bool are_GC_task_threads, bool are_ConcurrentGC_threads);
 // Run a task, returns when the task is done (or terminated).
 virtual void run_task(AbstractGangTask* task);
 void run_task(AbstractGangTask* task, uint no_of_parallel_workers);
 // Allocate a worker and return a pointer to it.
-virtual GangWorker* allocate_worker(int which);
+virtual GangWorker* allocate_worker(uint which);
 // Initialize workers in the gang.  Return true if initialization
 // succeeded. The type of the worker can be overridden in a derived
 // class with the appropriate implementation of allocate_worker().
 bool initialize_workers();
 };
 // As described above _active_workers determines the number
 // of threads started on a task.  It must also be used to
 // determine completion.
 protected:
-int _active_workers;
+uint _active_workers;
 public:
 // Constructor and destructor.
 // Initialize active_workers to a minimum value.  Setting it to
 // the parameter "workers" will initialize it to a maximum
 // value which is not desirable.
-FlexibleWorkGang(const char* name, int workers,
+FlexibleWorkGang(const char* name, uint workers,
 bool are_GC_task_threads,
 bool  are_ConcurrentGC_threads) :
 WorkGang(name, workers, are_GC_task_threads, are_ConcurrentGC_threads),
-_active_workers(UseDynamicNumberOfGCThreads ? 1 : ParallelGCThreads) {};
+_active_workers(UseDynamicNumberOfGCThreads ? 1U : ParallelGCThreads) {}
 // Accessors for fields
-virtual int active_workers() const { return _active_workers; }
+virtual uint active_workers() const { return _active_workers; }
-void set_active_workers(int v) {
+void set_active_workers(uint v) {
 assert(v <= _total_workers,
 "Trying to set more workers active than there are");
 _active_workers = MIN2(v, _total_workers);
 assert(v != 0, "Trying to set active workers to 0");
-_active_workers = MAX2(1, _active_workers);
+_active_workers = MAX2(1U, _active_workers);
 assert(UseDynamicNumberOfGCThreads || _active_workers == _total_workers,
 "Unless dynamic should use total workers");
 }
 virtual void run_task(AbstractGangTask* task);
 virtual bool needs_more_workers() const {
 // before any of them may leave.
 class WorkGangBarrierSync : public StackObj {
 protected:
 Monitor _monitor;
-int     _n_workers;
+uint     _n_workers;
-int     _n_completed;
+uint     _n_completed;
 bool    _should_reset;
 Monitor* monitor()        { return &_monitor; }
-int      n_workers()      { return _n_workers; }
+uint     n_workers()      { return _n_workers; }
-int      n_completed()    { return _n_completed; }
+uint     n_completed()    { return _n_completed; }
 bool     should_reset()   { return _should_reset; }
 void     zero_completed() { _n_completed = 0; }
 void     inc_completed()  { _n_completed++; }
 void     set_should_reset(bool v) { _should_reset = v; }
 public:
 WorkGangBarrierSync();
-WorkGangBarrierSync(int n_workers, const char* name);
+WorkGangBarrierSync(uint n_workers, const char* name);
 // Set the number of workers that will use the barrier.
 // Must be called before any of the workers start running.
-void set_n_workers(int n_workers);
+void set_n_workers(uint n_workers);
 // Enter the barrier. A worker that enters the barrier will
 // not be allowed to leave until all other threads have
 // also entered the barrier.
 void enter();
 // A class to manage claiming of subtasks within a group of tasks.  The
 // subtasks will be identified by integer indices, usually elements of an
 // enumeration type.
-class SubTasksDone: public CHeapObj {
+class SubTasksDone : public CHeapObj {
-jint* _tasks;
+uint* _tasks;
-int _n_tasks;
+uint _n_tasks;
 // _n_threads is used to determine when a sub task is done.
 // It does not control how many threads will execute the subtask
 // but must be initialized to the number that do execute the task
 // in order to correctly decide when the subtask is done (all the
 // threads working on the task have finished).
-int _n_threads;
+uint _n_threads;
-jint _threads_completed;
+uint _threads_completed;
 #ifdef ASSERT
-volatile jint _claimed;
+volatile uint _claimed;
 #endif
 // Set all tasks to unclaimed.
 void clear();
 public:
 // Initializes "this" to a state in which there are "n" tasks to be
 // processed, none of the which are originally claimed.  The number of
 // threads doing the tasks is initialized 1.
-SubTasksDone(int n);
+SubTasksDone(uint n);
 // True iff the object is in a valid state.
 bool valid();
 // Get/set the number of parallel threads doing the tasks to "t".  Can only
 // be called before tasks start or after they are complete.
-int n_threads() { return _n_threads; }
+uint n_threads() { return _n_threads; }
-void set_n_threads(int t);
+void set_n_threads(uint t);
 // Returns "false" if the task "t" is unclaimed, and ensures that task is
 // claimed.  The task "t" is required to be within the range of "this".
-bool is_task_claimed(int t);
+bool is_task_claimed(uint t);
 // The calling thread asserts that it has attempted to claim all the
 // tasks that it will try to claim.  Every thread in the parallel task
 // must execute this.  (When the last thread does so, the task array is
 // cleared.)
 // set scanning). Note that unlike the above class this is
 // a stack object - is there any reason for it not to be?
 class SequentialSubTasksDone : public StackObj {
 protected:
-jint _n_tasks;     // Total number of tasks available.
+uint _n_tasks;     // Total number of tasks available.
-jint _n_claimed;   // Number of tasks claimed.
+uint _n_claimed;   // Number of tasks claimed.
 // _n_threads is used to determine when a sub task is done.
 // See comments on SubTasksDone::_n_threads
-jint _n_threads;   // Total number of parallel threads.
+uint _n_threads;   // Total number of parallel threads.
-jint _n_completed; // Number of completed threads.
+uint _n_completed; // Number of completed threads.
 void clear();
 public:
 SequentialSubTasksDone() {
 // True iff the object is in a valid state.
 bool valid();
 // number of tasks
-jint n_tasks() const { return _n_tasks; }
+uint n_tasks() const { return _n_tasks; }
 // Get/set the number of parallel threads doing the tasks to t.
 // Should be called before the task starts but it is safe
 // to call this once a task is running provided that all
 // threads agree on the number of threads.
-int n_threads() { return _n_threads; }
+uint n_threads() { return _n_threads; }
-void set_n_threads(int t) { _n_threads = t; }
+void set_n_threads(uint t) { _n_threads = t; }
 // Set the number of tasks to be claimed to t. As above,
 // should be called before the tasks start but it is safe
 // to call this once a task is running provided all threads
 // agree on the number of tasks.
-void set_n_tasks(int t) { _n_tasks = t; }
+void set_n_tasks(uint t) { _n_tasks = t; }
 // Returns false if the next task in the sequence is unclaimed,
 // and ensures that it is claimed. Will set t to be the index
 // of the claimed task in the sequence. Will return true if
 // the task cannot be claimed and there are none left to claim.
-bool is_task_claimed(int& t);
+bool is_task_claimed(uint& t);
 // The calling thread asserts that it has attempted to claim
 // all the tasks it possibly can in the sequence. Every thread
 // claiming tasks must promise call this. Returns true if this
 // is the last thread to complete so that the thread can perform

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/utilities/workgroup.hpp @ 4728:441e946dc1af