/*

 * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#ifndef SHARE_RUNTIME_THREAD_HPP

#define SHARE_RUNTIME_THREAD_HPP

#include "jni.h"

#include "code/compiledMethod.hpp"

#include "gc/shared/gcThreadLocalData.hpp"

#include "gc/shared/threadLocalAllocBuffer.hpp"

#include "memory/allocation.hpp"

#include "oops/oop.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/frame.hpp"

#include "runtime/globals.hpp"

#include "runtime/handshake.hpp"

#include "runtime/javaFrameAnchor.hpp"

#include "runtime/jniHandles.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/os.hpp"

#include "runtime/osThread.hpp"

#include "runtime/park.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/threadHeapSampler.hpp"

#include "runtime/threadLocalStorage.hpp"

#include "runtime/threadStatisticalInfo.hpp"

#include "runtime/unhandledOops.hpp"

#include "utilities/align.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/macros.hpp"

#ifdef ZERO

# include "stack_zero.hpp"

#endif

#if INCLUDE_JFR

#include "jfr/support/jfrThreadExtension.hpp"

#endif

class SafeThreadsListPtr;

class ThreadSafepointState;

class ThreadsList;

class ThreadsSMRSupport;

class JvmtiThreadState;

class ThreadStatistics;

class ConcurrentLocksDump;

class ParkEvent;

class Parker;

class MonitorInfo;

class ciEnv;

class CompileThread;

class CompileLog;

class CompileTask;

class CompileQueue;

class CompilerCounters;

class vframeArray;

class vframe;

class javaVFrame;

class DeoptResourceMark;

class jvmtiDeferredLocalVariableSet;

class GCTaskQueue;

class ThreadClosure;

class ICRefillVerifier;

class IdealGraphPrinter;

class JVMCIEnv;

class JVMCIPrimitiveArray;

class Metadata;

class ResourceArea;

DEBUG_ONLY(class ResourceMark;)

class WorkerThread;

// Class hierarchy

// - Thread

//   - JavaThread

//     - various subclasses eg CompilerThread, ServiceThread

//   - NonJavaThread

//     - NamedThread

//       - VMThread

//       - ConcurrentGCThread

//       - WorkerThread

//         - GangWorker

//         - GCTaskThread

//     - WatcherThread

//     - JfrThreadSampler

//

// All Thread subclasses must be either JavaThread or NonJavaThread.

// This means !t->is_Java_thread() iff t is a NonJavaThread, or t is

// a partially constructed/destroyed Thread.

// Thread execution sequence and actions:

// All threads:

//  - thread_native_entry  // per-OS native entry point

//    - stack initialization

//    - other OS-level initialization (signal masks etc)

//    - handshake with creating thread (if not started suspended)

//    - this->call_run()  // common shared entry point

//      - shared common initialization

//      - this->pre_run()  // virtual per-thread-type initialization

//      - this->run()      // virtual per-thread-type "main" logic

//      - shared common tear-down

//      - this->post_run()  // virtual per-thread-type tear-down

//      - // 'this' no longer referenceable

//    - OS-level tear-down (minimal)

//    - final logging

//

// For JavaThread:

//   - this->run()  // virtual but not normally overridden

//     - this->thread_main_inner()  // extra call level to ensure correct stack calculations

//       - this->entry_point()  // set differently for each kind of JavaThread

class Thread: public ThreadShadow {

  friend class VMStructs;

  friend class JVMCIVMStructs;

 private:

#ifndef USE_LIBRARY_BASED_TLS_ONLY

  // Current thread is maintained as a thread-local variable

  static THREAD_LOCAL_DECL Thread* _thr_current;

#endif

  // Thread local data area available to the GC. The internal

  // structure and contents of this data area is GC-specific.

  // Only GC and GC barrier code should access this data area.

  GCThreadLocalData _gc_data;

 public:

  static ByteSize gc_data_offset() {

    return byte_offset_of(Thread, _gc_data);

  }

  template <typename T> T* gc_data() {

    STATIC_ASSERT(sizeof(T) <= sizeof(_gc_data));

    return reinterpret_cast<T*>(&_gc_data);

  }

  // Exception handling

  // (Note: _pending_exception and friends are in ThreadShadow)

  //oop       _pending_exception;                // pending exception for current thread

  // const char* _exception_file;                   // file information for exception (debugging only)

  // int         _exception_line;                   // line information for exception (debugging only)

 protected:

  DEBUG_ONLY(static Thread* _starting_thread;)

  // Support for forcing alignment of thread objects for biased locking

  void*       _real_malloc_address;

  // JavaThread lifecycle support:

  friend class SafeThreadsListPtr;  // for _threads_list_ptr, cmpxchg_threads_hazard_ptr(), {dec_,inc_,}nested_threads_hazard_ptr_cnt(), {g,s}et_threads_hazard_ptr(), inc_nested_handle_cnt(), tag_hazard_ptr() access

  friend class ScanHazardPtrGatherProtectedThreadsClosure;  // for cmpxchg_threads_hazard_ptr(), get_threads_hazard_ptr(), is_hazard_ptr_tagged() access

  friend class ScanHazardPtrGatherThreadsListClosure;  // for get_threads_hazard_ptr(), untag_hazard_ptr() access

  friend class ScanHazardPtrPrintMatchingThreadsClosure;  // for get_threads_hazard_ptr(), is_hazard_ptr_tagged() access

  friend class ThreadsSMRSupport;  // for _nested_threads_hazard_ptr_cnt, _threads_hazard_ptr, _threads_list_ptr access

  ThreadsList* volatile _threads_hazard_ptr;

  SafeThreadsListPtr*   _threads_list_ptr;

  ThreadsList*          cmpxchg_threads_hazard_ptr(ThreadsList* exchange_value, ThreadsList* compare_value);

  ThreadsList*          get_threads_hazard_ptr();

  void                  set_threads_hazard_ptr(ThreadsList* new_list);

  static bool           is_hazard_ptr_tagged(ThreadsList* list) {

    return (intptr_t(list) & intptr_t(1)) == intptr_t(1);

  }

  static ThreadsList*   tag_hazard_ptr(ThreadsList* list) {

    return (ThreadsList*)(intptr_t(list) | intptr_t(1));

  }

  static ThreadsList*   untag_hazard_ptr(ThreadsList* list) {

    return (ThreadsList*)(intptr_t(list) & ~intptr_t(1));

  }

  // This field is enabled via -XX:+EnableThreadSMRStatistics:

  uint _nested_threads_hazard_ptr_cnt;

  void dec_nested_threads_hazard_ptr_cnt() {

    assert(_nested_threads_hazard_ptr_cnt != 0, "mismatched {dec,inc}_nested_threads_hazard_ptr_cnt()");

    _nested_threads_hazard_ptr_cnt--;

  }

  void inc_nested_threads_hazard_ptr_cnt() {

    _nested_threads_hazard_ptr_cnt++;

  }

  uint nested_threads_hazard_ptr_cnt() {

    return _nested_threads_hazard_ptr_cnt;

  }

 public:

  void* operator new(size_t size) throw() { return allocate(size, true); }

  void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {

    return allocate(size, false); }

  void  operator delete(void* p);

 protected:

  static void* allocate(size_t size, bool throw_excpt, MEMFLAGS flags = mtThread);

 private:

  // ***************************************************************

  // Suspend and resume support

  // ***************************************************************

  //

  // VM suspend/resume no longer exists - it was once used for various

  // things including safepoints but was deprecated and finally removed

  // in Java 7. Because VM suspension was considered "internal" Java-level

  // suspension was considered "external", and this legacy naming scheme

  // remains.

  //

  // External suspend/resume requests come from JVM_SuspendThread,

  // JVM_ResumeThread, JVMTI SuspendThread, and finally JVMTI

  // ResumeThread. External

  // suspend requests cause _external_suspend to be set and external

  // resume requests cause _external_suspend to be cleared.

  // External suspend requests do not nest on top of other external

  // suspend requests. The higher level APIs reject suspend requests

  // for already suspended threads.

  //

  // The external_suspend

  // flag is checked by has_special_runtime_exit_condition() and java thread

  // will self-suspend when handle_special_runtime_exit_condition() is

  // called. Most uses of the _thread_blocked state in JavaThreads are

  // considered the same as being externally suspended; if the blocking

  // condition lifts, the JavaThread will self-suspend. Other places

  // where VM checks for external_suspend include:

  //   + mutex granting (do not enter monitors when thread is suspended)

  //   + state transitions from _thread_in_native

  //

  // In general, java_suspend() does not wait for an external suspend

  // request to complete. When it returns, the only guarantee is that

  // the _external_suspend field is true.

  //

  // wait_for_ext_suspend_completion() is used to wait for an external

  // suspend request to complete. External suspend requests are usually

  // followed by some other interface call that requires the thread to

  // be quiescent, e.g., GetCallTrace(). By moving the "wait time" into

  // the interface that requires quiescence, we give the JavaThread a

  // chance to self-suspend before we need it to be quiescent. This

  // improves overall suspend/query performance.

  //

  // _suspend_flags controls the behavior of java_ suspend/resume.

  // It must be set under the protection of SR_lock. Read from the flag is

  // OK without SR_lock as long as the value is only used as a hint.

  // (e.g., check _external_suspend first without lock and then recheck

  // inside SR_lock and finish the suspension)

  //

  // _suspend_flags is also overloaded for other "special conditions" so

  // that a single check indicates whether any special action is needed

  // eg. for async exceptions.

  // -------------------------------------------------------------------

  // Notes:

  // 1. The suspend/resume logic no longer uses ThreadState in OSThread

  // but we still update its value to keep other part of the system (mainly

  // JVMTI) happy. ThreadState is legacy code (see notes in

  // osThread.hpp).

  //

  // 2. It would be more natural if set_external_suspend() is private and

  // part of java_suspend(), but that probably would affect the suspend/query

  // performance. Need more investigation on this.

  // suspend/resume lock: used for self-suspend

  Monitor* _SR_lock;

 protected:

  enum SuspendFlags {

    // NOTE: avoid using the sign-bit as cc generates different test code

    //       when the sign-bit is used, and sometimes incorrectly - see CR 6398077

    _external_suspend       = 0x20000000U, // thread is asked to self suspend

    _ext_suspended          = 0x40000000U, // thread has self-suspended

    _has_async_exception    = 0x00000001U, // there is a pending async exception

    _critical_native_unlock = 0x00000002U, // Must call back to unlock JNI critical lock

    _trace_flag             = 0x00000004U  // call tracing backend

  };

  // various suspension related flags - atomically updated

  // overloaded for async exception checking in check_special_condition_for_native_trans.

  volatile uint32_t _suspend_flags;

 private:

  int _num_nested_signal;

  DEBUG_ONLY(bool _suspendible_thread;)

 public:

  void enter_signal_handler() { _num_nested_signal++; }

  void leave_signal_handler() { _num_nested_signal--; }

  bool is_inside_signal_handler() const { return _num_nested_signal > 0; }

  // Determines if a heap allocation failure will be retried

  // (e.g., by deoptimizing and re-executing in the interpreter).

  // In this case, the failed allocation must raise

  // Universe::out_of_memory_error_retry() and omit side effects

  // such as JVMTI events and handling -XX:+HeapDumpOnOutOfMemoryError

  // and -XX:OnOutOfMemoryError.

  virtual bool in_retryable_allocation() const { return false; }

#ifdef ASSERT

  void set_suspendible_thread() {

    _suspendible_thread = true;

  }

  void clear_suspendible_thread() {

    _suspendible_thread = false;

  }

  bool is_suspendible_thread() { return _suspendible_thread; }

#endif

 private:

  // Active_handles points to a block of handles

  JNIHandleBlock* _active_handles;

  // One-element thread local free list

  JNIHandleBlock* _free_handle_block;

  // Point to the last handle mark

  HandleMark* _last_handle_mark;

  // Claim value for parallel iteration over threads.

  uintx _threads_do_token;

  // Support for GlobalCounter

 private:

  volatile uintx _rcu_counter;

 public:

  volatile uintx* get_rcu_counter() {

    return &_rcu_counter;

  }

 public:

  void set_last_handle_mark(HandleMark* mark)   { _last_handle_mark = mark; }

  HandleMark* last_handle_mark() const          { return _last_handle_mark; }

 private:

#ifdef ASSERT

  ICRefillVerifier* _missed_ic_stub_refill_verifier;

 public:

  ICRefillVerifier* missed_ic_stub_refill_verifier() {

    return _missed_ic_stub_refill_verifier;

  }

  void set_missed_ic_stub_refill_verifier(ICRefillVerifier* verifier) {

    _missed_ic_stub_refill_verifier = verifier;

  }

#endif

 private:

  // debug support for checking if code does allow safepoints or not

  // GC points in the VM can happen because of allocation, invoking a VM operation, or blocking on

  // mutex, or blocking on an object synchronizer (Java locking).

  // If !allow_safepoint(), then an assertion failure will happen in any of the above cases

  // If !allow_allocation(), then an assertion failure will happen during allocation

  // (Hence, !allow_safepoint() => !allow_allocation()).

  //

  // The two classes NoSafepointVerifier and No_Allocation_Verifier are used to set these counters.

  //

  NOT_PRODUCT(int _allow_safepoint_count;)      // If 0, thread allow a safepoint to happen

  debug_only(int _allow_allocation_count;)     // If 0, the thread is allowed to allocate oops.

  // Used by SkipGCALot class.

  NOT_PRODUCT(bool _skip_gcalot;)               // Should we elide gc-a-lot?

  friend class NoAllocVerifier;

  friend class NoSafepointVerifier;

  friend class PauseNoSafepointVerifier;

  friend class GCLocker;

  volatile void* _polling_page;                 // Thread local polling page

  ThreadLocalAllocBuffer _tlab;                 // Thread-local eden

  jlong _allocated_bytes;                       // Cumulative number of bytes allocated on

                                                // the Java heap

  ThreadHeapSampler _heap_sampler;              // For use when sampling the memory.

  ThreadStatisticalInfo _statistical_info;      // Statistics about the thread

  JFR_ONLY(DEFINE_THREAD_LOCAL_FIELD_JFR;)      // Thread-local data for jfr

  int   _vm_operation_started_count;            // VM_Operation support

  int   _vm_operation_completed_count;          // VM_Operation support

  ObjectMonitor* _current_pending_monitor;      // ObjectMonitor this thread

                                                // is waiting to lock

  bool _current_pending_monitor_is_from_java;   // locking is from Java code

  // ObjectMonitor on which this thread called Object.wait()

  ObjectMonitor* _current_waiting_monitor;

  // Private thread-local objectmonitor list - a simple cache organized as a SLL.

 public:

  ObjectMonitor* omFreeList;

  int omFreeCount;                              // length of omFreeList

  int omFreeProvision;                          // reload chunk size

  ObjectMonitor* omInUseList;                   // SLL to track monitors in circulation

  int omInUseCount;                             // length of omInUseList

#ifdef ASSERT

 private:

  volatile uint64_t _visited_for_critical_count;

 public:

  void set_visited_for_critical_count(uint64_t safepoint_id) {

    assert(_visited_for_critical_count == 0, "Must be reset before set");

    assert((safepoint_id & 0x1) == 1, "Must be odd");

    _visited_for_critical_count = safepoint_id;

  }

  void reset_visited_for_critical_count(uint64_t safepoint_id) {

    assert(_visited_for_critical_count == safepoint_id, "Was not visited");

    _visited_for_critical_count = 0;

  }

  bool was_visited_for_critical_count(uint64_t safepoint_id) const {

    return _visited_for_critical_count == safepoint_id;

  }

#endif

 public:

  enum {

    is_definitely_current_thread = true

  };

  // Constructor

  Thread();

  virtual ~Thread() = 0;        // Thread is abstract.

  // Manage Thread::current()

  void initialize_thread_current();

  static void clear_thread_current(); // TLS cleanup needed before threads terminate

 protected:

  // To be implemented by children.

  virtual void run() = 0;

  virtual void pre_run() = 0;

  virtual void post_run() = 0;  // Note: Thread must not be deleted prior to calling this!

#ifdef ASSERT

  enum RunState {

    PRE_CALL_RUN,

    CALL_RUN,

    PRE_RUN,

    RUN,

    POST_RUN

    // POST_CALL_RUN - can't define this one as 'this' may be deleted when we want to set it

  };

  RunState _run_state;  // for lifecycle checks

#endif

 public:

  // invokes <ChildThreadClass>::run(), with common preparations and cleanups.

  void call_run();

  // Testers

  virtual bool is_VM_thread()       const            { return false; }

  virtual bool is_Java_thread()     const            { return false; }

  virtual bool is_Compiler_thread() const            { return false; }

  virtual bool is_Code_cache_sweeper_thread() const  { return false; }

  virtual bool is_hidden_from_external_view() const  { return false; }

  virtual bool is_jvmti_agent_thread() const         { return false; }

  // True iff the thread can perform GC operations at a safepoint.

  // Generally will be true only of VM thread and parallel GC WorkGang

  // threads.

  virtual bool is_GC_task_thread() const             { return false; }

  virtual bool is_Watcher_thread() const             { return false; }

  virtual bool is_ConcurrentGC_thread() const        { return false; }

  virtual bool is_Named_thread() const               { return false; }

  virtual bool is_Worker_thread() const              { return false; }

  // Can this thread make Java upcalls

  virtual bool can_call_java() const                 { return false; }

  // Casts

  virtual WorkerThread* as_Worker_thread() const     { return NULL; }