/*

 * Copyright (c) 1997, 2013, 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_VM_RUNTIME_THREAD_HPP

#define SHARE_VM_RUNTIME_THREAD_HPP

#include "memory/allocation.hpp"

#include "memory/threadLocalAllocBuffer.hpp"

#include "oops/oop.hpp"

#include "prims/jni.h"

#include "prims/jvmtiExport.hpp"

#include "runtime/frame.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/safepoint.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/threadLocalStorage.hpp"

#include "runtime/unhandledOops.hpp"

#include "utilities/macros.hpp"

#if INCLUDE_NMT

#include "services/memRecorder.hpp"

#endif // INCLUDE_NMT

#include "trace/traceBackend.hpp"

#include "trace/traceMacros.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/top.hpp"

#if INCLUDE_ALL_GCS

#include "gc_implementation/g1/dirtyCardQueue.hpp"

#include "gc_implementation/g1/satbQueue.hpp"

#endif // INCLUDE_ALL_GCS

#ifdef ZERO

#ifdef TARGET_ARCH_zero

# include "stack_zero.hpp"

#endif

#endif

class ThreadSafepointState;

class ThreadProfiler;

class JvmtiThreadState;

class JvmtiGetLoadedClassesClosure;

class ThreadStatistics;

class ConcurrentLocksDump;

class ParkEvent;

class Parker;

class ciEnv;

class CompileThread;

class CompileLog;

class CompileTask;

class CompileQueue;

class CompilerCounters;

class vframeArray;

class DeoptResourceMark;

class jvmtiDeferredLocalVariableSet;

class GCTaskQueue;

class ThreadClosure;

class IdealGraphPrinter;

DEBUG_ONLY(class ResourceMark;)

class WorkerThread;

// Class hierarchy

// - Thread

//   - NamedThread

//     - VMThread

//     - ConcurrentGCThread

//     - WorkerThread

//       - GangWorker

//       - GCTaskThread

//   - JavaThread

//   - WatcherThread

class Thread: public ThreadShadow {

  friend class VMStructs;

 private:

  // 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:

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

  void*       _real_malloc_address;

 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

    _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt

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

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

  };

  // 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;

 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; }

 private:

  // Debug tracing

  static void trace(const char* msg, const Thread* const thread) PRODUCT_RETURN;

  // 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;

  // The parity of the last strong_roots iteration in which this thread was

  // claimed as a task.

  jint _oops_do_parity;

  public:

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

   HandleMark* last_handle_mark() const          { return _last_handle_mark; }

  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 No_Safepoint_Verifier 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?

  // Record when GC is locked out via the GC_locker mechanism

  CHECK_UNHANDLED_OOPS_ONLY(int _gc_locked_out_count;)

  friend class No_Alloc_Verifier;

  friend class No_Safepoint_Verifier;

  friend class Pause_No_Safepoint_Verifier;

  friend class ThreadLocalStorage;

  friend class GC_locker;

  ThreadLocalAllocBuffer _tlab;                 // Thread-local eden

  jlong _allocated_bytes;                       // Cumulative number of bytes allocated on

                                                // the Java heap

  TRACE_DATA _trace_data;                       // Thread-local data for tracing

  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:

  bool _visited_for_critical_count;

 public:

  void set_visited_for_critical_count(bool z) { _visited_for_critical_count = z; }

  bool was_visited_for_critical_count() const   { return _visited_for_critical_count; }

#endif

 public:

  enum {

    is_definitely_current_thread = true

  };

  // Constructor

  Thread();

  virtual ~Thread();

  // initializtion

  void initialize_thread_local_storage();

  // thread entry point

  virtual void 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_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; }

  // Casts

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

  virtual char* name() const { return (char*)"Unknown thread"; }

  // Returns the current thread

  static inline Thread* current();

  // Common thread operations

  static void set_priority(Thread* thread, ThreadPriority priority);

  static ThreadPriority get_priority(const Thread* const thread);

  static void start(Thread* thread);

  static void interrupt(Thread* thr);

  static bool is_interrupted(Thread* thr, bool clear_interrupted);

  void set_native_thread_name(const char *name) {

    assert(Thread::current() == this, "set_native_thread_name can only be called on the current thread");

    os::set_native_thread_name(name);

  }

  ObjectMonitor** omInUseList_addr()             { return (ObjectMonitor **)&omInUseList; }

  Monitor* SR_lock() const                       { return _SR_lock; }

  bool has_async_exception() const { return (_suspend_flags & _has_async_exception) != 0; }

  void set_suspend_flag(SuspendFlags f) {

    assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");

    uint32_t flags;

    do {

      flags = _suspend_flags;

    }

    while (Atomic::cmpxchg((jint)(flags | f),

                           (volatile jint*)&_suspend_flags,

                           (jint)flags) != (jint)flags);

  }

  void clear_suspend_flag(SuspendFlags f) {

    assert(sizeof(jint) == sizeof(_suspend_flags), "size mismatch");

    uint32_t flags;

    do {

      flags = _suspend_flags;

    }

    while (Atomic::cmpxchg((jint)(flags & ~f),

                           (volatile jint*)&_suspend_flags,

                           (jint)flags) != (jint)flags);

  }

  void set_has_async_exception() {

    set_suspend_flag(_has_async_exception);

  }

  void clear_has_async_exception() {

    clear_suspend_flag(_has_async_exception);

  }

  bool do_critical_native_unlock() const { return (_suspend_flags & _critical_native_unlock) != 0; }

  void set_critical_native_unlock() {

    set_suspend_flag(_critical_native_unlock);

  }

  void clear_critical_native_unlock() {

    clear_suspend_flag(_critical_native_unlock);

  }

  // Support for Unhandled Oop detection

#ifdef CHECK_UNHANDLED_OOPS

 private:

  UnhandledOops* _unhandled_oops;

 public:

  UnhandledOops* unhandled_oops() { return _unhandled_oops; }

  // Mark oop safe for gc.  It may be stack allocated but won't move.

  void allow_unhandled_oop(oop *op) {

    if (CheckUnhandledOops) unhandled_oops()->allow_unhandled_oop(op);

  }

  // Clear oops at safepoint so crashes point to unhandled oop violator

  void clear_unhandled_oops() {

    if (CheckUnhandledOops) unhandled_oops()->clear_unhandled_oops();

  }

  bool is_gc_locked_out() { return _gc_locked_out_count > 0; }

#endif // CHECK_UNHANDLED_OOPS

#ifndef PRODUCT

  bool skip_gcalot()           { return _skip_gcalot; }

  void set_skip_gcalot(bool v) { _skip_gcalot = v;    }

#endif

 public:

  // Installs a pending exception to be inserted later

  static void send_async_exception(oop thread_oop, oop java_throwable);

  // Resource area

  ResourceArea* resource_area() const            { return _resource_area; }

  void set_resource_area(ResourceArea* area)     { _resource_area = area; }

  OSThread* osthread() const                     { return _osthread;   }

  void set_osthread(OSThread* thread)            { _osthread = thread; }

  // JNI handle support

  JNIHandleBlock* active_handles() const         { return _active_handles; }

  void set_active_handles(JNIHandleBlock* block) { _active_handles = block; }

  JNIHandleBlock* free_handle_block() const      { return _free_handle_block; }

  void set_free_handle_block(JNIHandleBlock* block) { _free_handle_block = block; }

  // Internal handle support

  HandleArea* handle_area() const                { return _handle_area; }

  void set_handle_area(HandleArea* area)         { _handle_area = area; }

  GrowableArray<Metadata*>* metadata_handles() const          { return _metadata_handles; }

  void set_metadata_handles(GrowableArray<Metadata*>* handles){ _metadata_handles = handles; }

  // Thread-Local Allocation Buffer (TLAB) support

  ThreadLocalAllocBuffer& tlab()                 { return _tlab; }

  void initialize_tlab() {

    if (UseTLAB) {

      tlab().initialize();

    }

  }

  jlong allocated_bytes()               { return _allocated_bytes; }

  void set_allocated_bytes(jlong value) { _allocated_bytes = value; }

  void incr_allocated_bytes(jlong size) { _allocated_bytes += size; }

  jlong cooked_allocated_bytes() {

    jlong allocated_bytes = OrderAccess::load_acquire(&_allocated_bytes);

    if (UseTLAB) {

      size_t used_bytes = tlab().used_bytes();

      if ((ssize_t)used_bytes > 0) {

        // More-or-less valid tlab.  The load_acquire above should ensure

        // that the result of the add is <= the instantaneous value

        return allocated_bytes + used_bytes;

      }

    }

    return allocated_bytes;

  }

  TRACE_DATA* trace_data()              { return &_trace_data; }

  // VM operation support

  int vm_operation_ticket()                      { return ++_vm_operation_started_count; }

  int vm_operation_completed_count()             { return _vm_operation_completed_count; }

  void increment_vm_operation_completed_count()  { _vm_operation_completed_count++; }

  // For tracking the heavyweight monitor the thread is pending on.

  ObjectMonitor* current_pending_monitor() {

    return _current_pending_monitor;

  }

  void set_current_pending_monitor(ObjectMonitor* monitor) {

    _current_pending_monitor = monitor;

  }

  void set_current_pending_monitor_is_from_java(bool from_java) {

    _current_pending_monitor_is_from_java = from_java;

  }

  bool current_pending_monitor_is_from_java() {

    return _current_pending_monitor_is_from_java;

  }

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

  ObjectMonitor* current_waiting_monitor() {

    return _current_waiting_monitor;

  }

  void set_current_waiting_monitor(ObjectMonitor* monitor) {

    _current_waiting_monitor = monitor;

  }

  // GC support

  // Apply "f->do_oop" to all root oops in "this".

  // Apply "cld_f->do_cld" to CLDs that are otherwise not kept alive.

  //   Used by JavaThread::oops_do.

  // Apply "cf->do_code_blob" (if !NULL) to all code blobs active in frames

  virtual void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);

  // Handles the parallel case for the method below.

private:

  bool claim_oops_do_par_case(int collection_parity);

public:

  // Requires that "collection_parity" is that of the current strong roots

  // iteration.  If "is_par" is false, sets the parity of "this" to

  // "collection_parity", and returns "true".  If "is_par" is true,

  // uses an atomic instruction to set the current threads parity to

  // "collection_parity", if it is not already.  Returns "true" iff the

  // calling thread does the update, this indicates that the calling thread

  // has claimed the thread's stack as a root groop in the current

  // collection.

  bool claim_oops_do(bool is_par, int collection_parity) {

    if (!is_par) {

      _oops_do_parity = collection_parity;

      return true;

    } else {

      return claim_oops_do_par_case(collection_parity);

    }

  }