1 /*
  2  * Copyright (c) 2002, 2019, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_GC_PARALLEL_GCTASKTHREAD_HPP
 26 #define SHARE_GC_PARALLEL_GCTASKTHREAD_HPP
 27 
 28 #include "runtime/thread.hpp"
 29 
 30 // Forward declarations of classes defined here.
 31 class GCTaskThread;
 32 class GCTaskTimeStamp;
 33 
 34 // Declarations of classes referenced in this file via pointer.
 35 class GCTaskManager;
 36 
 37 class GCTaskThread : public WorkerThread {
 38   friend class GCTaskManager;
 39 private:
 40   // Instance state.
 41   GCTaskManager* _manager;              // Manager for worker.
 42   const uint     _processor_id;         // Which processor the worker is on.
 43 
 44   GCTaskTimeStamp* _time_stamps;
 45   uint _time_stamp_index;
 46 
 47   GCTaskTimeStamp* time_stamp_at(uint index);
 48   void add_task_timestamp(const char* name, jlong t_entry, jlong t_exit);
 49 
 50   bool _is_working;                     // True if participating in GC tasks
 51 
 52   // Factory create and destroy methods.
 53   static GCTaskThread* create(GCTaskManager* manager,
 54                               uint           which,
 55                               uint           processor_id) {
 56     return new GCTaskThread(manager, which, processor_id);
 57   }
 58  public:
 59 
 60   static void destroy(GCTaskThread* manager) {
 61     if (manager != NULL) {
 62       delete manager;
 63     }
 64   }
 65   // Methods from Thread.
 66   bool is_GC_task_thread() const {
 67     return true;
 68   }
 69   virtual void run();
 70 
 71   void print_task_time_stamps();
 72 
 73 protected:
 74   // Constructor.  Clients use factory, but there could be subclasses.
 75   GCTaskThread(GCTaskManager* manager, uint which, uint processor_id);
 76   // Destructor: virtual destructor because of virtual methods.
 77   virtual ~GCTaskThread();
 78   // Accessors.
 79   GCTaskManager* manager() const {
 80     return _manager;
 81   }
 82   uint which() const {
 83     return id();
 84   }
 85   uint processor_id() const {
 86     return _processor_id;
 87   }
 88   void set_is_working(bool v) { _is_working = v; }
 89 };
 90 
 91 class GCTaskTimeStamp : public CHeapObj<mtGC>
 92 {
 93  private:
 94   jlong  _entry_time;
 95   jlong  _exit_time;
 96   const char*  _name;
 97 
 98  public:
 99   jlong entry_time()              { return _entry_time; }
100   jlong exit_time()               { return _exit_time; }
101   const char* name() const        { return _name; }
102 
103   void set_entry_time(jlong time) { _entry_time = time; }
104   void set_exit_time(jlong time)  { _exit_time = time; }
105   void set_name(const char* name) { _name = name; }
106 };
107 
108 #endif // SHARE_GC_PARALLEL_GCTASKTHREAD_HPP