1 /* 2 * Copyright (c) 2002, 2015, 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 public: 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 static void destroy(GCTaskThread* manager) { 59 if (manager != NULL) { 60 delete manager; 61 } 62 } 63 // Methods from Thread. 64 bool is_GC_task_thread() const { 65 return true; 66 } 67 virtual void run(); 68 // Methods. 69 void start(); 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 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 (const char*)_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(char* name) { _name = name; } 106 }; 107 108 #endif // SHARE_VM_GC_PARALLEL_GCTASKTHREAD_HPP