1 /* 2 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2021, Azul Systems, Inc. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #ifndef SHARE_RUNTIME_THREADS_HPP 27 #define SHARE_RUNTIME_THREADS_HPP 28 29 #include "jni.h" 30 #include "utilities/exceptions.hpp" 31 #include "utilities/globalDefinitions.hpp" 32 #include "utilities/macros.hpp" 33 34 class JavaThread; 35 class Metadata; 36 class MetadataClosure; 37 class OopClosure; 38 class Thread; 39 class ThreadClosure; 40 class ThreadsList; 41 class outputStream; 42 43 // The active thread queue. It also keeps track of the current used 44 // thread priorities. 45 class Threads: AllStatic { 46 friend class VMStructs; 47 private: 48 static int _number_of_threads; 49 static int _number_of_non_daemon_threads; 50 static int _return_code; 51 static uintx _thread_claim_token; 52 #ifdef ASSERT 53 static bool _vm_complete; 54 #endif 55 56 static void initialize_java_lang_classes(JavaThread* main_thread, TRAPS); 57 static void initialize_jsr292_core_classes(TRAPS); 58 59 public: 60 // Thread management 61 // force_daemon is a concession to JNI, where we may need to add a 62 // thread to the thread list before allocating its thread object 63 static void add(JavaThread* p, bool force_daemon = false); 64 static void remove(JavaThread* p, bool is_daemon); 65 static void non_java_threads_do(ThreadClosure* tc); 66 static void java_threads_do(ThreadClosure* tc); 67 static void threads_do(ThreadClosure* tc); 68 static void possibly_parallel_threads_do(bool is_par, ThreadClosure* tc); 69 70 // Initializes the vm and creates the vm thread 71 static jint create_vm(JavaVMInitArgs* args, bool* canTryAgain); 72 static void convert_vm_init_libraries_to_agents(); 73 static void create_vm_init_libraries(); 74 static void create_vm_init_agents(); 75 static void shutdown_vm_agents(); 76 static void destroy_vm(); 77 // Supported VM versions via JNI 78 // Includes JNI_VERSION_1_1 79 static jboolean is_supported_jni_version_including_1_1(jint version); 80 // Does not include JNI_VERSION_1_1 81 static jboolean is_supported_jni_version(jint version); 82 83 private: 84 // The "thread claim token" provides a way for threads to be claimed 85 // by parallel worker tasks. 86 // 87 // Each thread contains a "token" field. A task will claim the 88 // thread only if its token is different from the global token, 89 // which is updated by calling change_thread_claim_token(). When 90 // a thread is claimed, it's token is set to the global token value 91 // so other threads in the same iteration pass won't claim it. 92 // 93 // For this to work change_thread_claim_token() needs to be called 94 // exactly once in sequential code before starting parallel tasks 95 // that should claim threads. 96 // 97 // New threads get their token set to 0 and change_thread_claim_token() 98 // never sets the global token to 0. 99 static uintx thread_claim_token() { return _thread_claim_token; } 100 101 public: 102 static void change_thread_claim_token(); 103 static void assert_all_threads_claimed() NOT_DEBUG_RETURN; 104 105 // Apply "f->do_oop" to all root oops in all threads. 106 // This version may only be called by sequential code. 107 static void oops_do(OopClosure* f, NMethodClosure* cf); 108 // This version may be called by sequential or parallel code. 109 static void possibly_parallel_oops_do(bool is_par, OopClosure* f, NMethodClosure* cf); 110 111 // RedefineClasses support 112 static void metadata_do(MetadataClosure* f); 113 static void metadata_handles_do(void f(Metadata*)); 114 115 #ifdef ASSERT 116 static bool is_vm_complete() { return _vm_complete; } 117 #endif // ASSERT 118 119 // Verification 120 static void verify(); 121 static void print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks, bool print_extended_info); 122 static void print(bool print_stacks, bool internal_format) { 123 // this function is only used by debug.cpp 124 print_on(tty, print_stacks, internal_format, false /* no concurrent lock printed */, false /* simple format */); 125 } 126 static void print_on_error(outputStream* st, Thread* current, char* buf, int buflen); 127 static void print_on_error(Thread* this_thread, outputStream* st, Thread* current, char* buf, 128 int buflen, bool* found_current); 129 // Print threads busy compiling, and returns the number of printed threads. 130 static unsigned print_threads_compiling(outputStream* st, char* buf, int buflen, bool short_form = false); 131 132 // Get Java threads that are waiting to enter or re-enter the specified monitor. 133 // Java threads that are executing mounted virtual threads are not included. 134 static GrowableArray<JavaThread*>* get_pending_threads(ThreadsList * t_list, 135 int count, address monitor); 136 137 // Get owning Java thread from the basicLock address. 138 static JavaThread *owning_thread_from_stacklock(ThreadsList * t_list, address basicLock); 139 140 static JavaThread* owning_thread_from_object(ThreadsList* t_list, oop obj); 141 static JavaThread* owning_thread_from_monitor(ThreadsList* t_list, ObjectMonitor* owner); 142 143 // Number of threads on the active threads list 144 static int number_of_threads() { return _number_of_threads; } 145 // Number of non-daemon threads on the active threads list 146 static int number_of_non_daemon_threads() { return _number_of_non_daemon_threads; } 147 148 struct Test; // For private gtest access. 149 }; 150 151 #endif // SHARE_RUNTIME_THREADS_HPP