1 /* 2 * Copyright (c) 2002, 2010, 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_IMPLEMENTATION_PARALLELSCAVENGE_GCTASKTHREAD_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_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 private: 39 // Instance state. 40 GCTaskManager* _manager; // Manager for worker. 41 const uint _processor_id; // Which processor the worker is on. 42 43 GCTaskTimeStamp* _time_stamps; 44 uint _time_stamp_index; 45 46 GCTaskTimeStamp* time_stamp_at(uint index); 47 48 public: 49 // Factory create and destroy methods. 50 static GCTaskThread* create(GCTaskManager* manager, 51 uint which, 52 uint processor_id) { 53 return new GCTaskThread(manager, which, processor_id); 54 } 55 static void destroy(GCTaskThread* manager) { 56 if (manager != NULL) { 57 delete manager; 58 } 59 } 60 // Methods from Thread. 61 bool is_GC_task_thread() const { 62 return true; 63 } 64 virtual void run(); 65 // Methods. 66 void start(); 67 68 void print_task_time_stamps(); 69 void print_on(outputStream* st) const; 70 void print() const { print_on(tty); } 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 }; 88 89 class GCTaskTimeStamp : public CHeapObj 90 { 91 private: 92 jlong _entry_time; 93 jlong _exit_time; 94 char* _name; 95 96 public: 97 jlong entry_time() { return _entry_time; } 98 jlong exit_time() { return _exit_time; } 99 const char* name() const { return (const char*)_name; } 100 101 void set_entry_time(jlong time) { _entry_time = time; } 102 void set_exit_time(jlong time) { _exit_time = time; } 103 void set_name(char* name) { _name = name; } 104 }; 105 106 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_GCTASKTHREAD_HPP