1 /* 2 * Copyright (c) 2002, 2016, 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_VM_GC_PARALLEL_GCTASKTHREAD_HPP 26 #define SHARE_VM_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 49 bool _is_working; // True if participating in GC tasks 50 51 // Factory create and destroy methods. 52 static GCTaskThread* create(GCTaskManager* manager, 53 uint which, 54 uint processor_id) { 55 return new GCTaskThread(manager, which, processor_id); 56 } 57 public: 58 59 static void destroy(GCTaskThread* manager) { 60 if (manager != NULL) { 61 delete manager; 62 } 63 } 64 // Methods from Thread. 65 bool is_GC_task_thread() const { 66 return true; 67 } 68 virtual void run(); 69 70 void print_task_time_stamps(); 71 72 protected: 73 // Constructor. Clients use factory, but there could be subclasses. 74 GCTaskThread(GCTaskManager* manager, uint which, uint processor_id); 75 // Destructor: virtual destructor because of virtual methods. 76 virtual ~GCTaskThread(); 77 // Accessors. 78 GCTaskManager* manager() const { 79 return _manager; 80 } 81 uint which() const { 82 return id(); 83 } 84 uint processor_id() const { 85 return _processor_id; 86 } 87 void set_is_working(bool v) { _is_working = v; } 88 }; 89 90 class GCTaskTimeStamp : public CHeapObj<mtGC> 91 { 92 private: 93 jlong _entry_time; 94 jlong _exit_time; 95 char* _name; 96 97 public: 98 jlong entry_time() { return _entry_time; } 99 jlong exit_time() { return _exit_time; } 100 const char* name() const { return (const char*)_name; } 101 102 void set_entry_time(jlong time) { _entry_time = time; } 103 void set_exit_time(jlong time) { _exit_time = time; } 104 void set_name(char* name) { _name = name; } 105 }; 106 107 #endif // SHARE_VM_GC_PARALLEL_GCTASKTHREAD_HPP