/*

 * Copyright 1997-2010 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

class ThreadSafepointState;

class ThreadProfiler;

class JvmtiThreadState;

class JvmtiGetLoadedClassesClosure;

class ThreadStatistics;

class ConcurrentLocksDump;

class ParkEvent ;

class ciEnv;

class CompileThread;

class CompileLog;

class CompileTask;

class CompileQueue;

class CompilerCounters;

class vframeArray;

class DeoptResourceMark;

class jvmtiDeferredLocalVariableSet;

class GCTaskQueue;

class ThreadClosure;

class IdealGraphPrinter;

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

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

  void*       _real_malloc_address;

 public:

  void* operator new(size_t size);

  void  operator delete(void* p);

 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

  };

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

  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

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

  // Remove this ifdef when C1 is ported to the compiler interface.

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

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

  }

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

  // Thread-Local Allocation Buffer (TLAB) support

  ThreadLocalAllocBuffer& tlab()                 { return _tlab; }

  void initialize_tlab() {

    if (UseTLAB) {

      tlab().initialize();

    }

  }

  // 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 "cf->do_code_blob" (if !NULL) to all code blobs active in frames

  void oops_do(OopClosure* 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);

    }

  }

  // Sweeper support

  void nmethods_do(CodeBlobClosure* cf);

  // Tells if adr belong to this thread. This is used

  // for checking if a lock is owned by the running thread.

  // Used by fast lock support

  virtual bool is_lock_owned(address adr) const;

  // Check if address is in the stack of the thread (not just for locks).

  // Warning: the method can only be used on the running thread

  bool is_in_stack(address adr) const;

  // Sets this thread as starting thread. Returns failure if thread

  // creation fails due to lack of memory, too many threads etc.

  bool set_as_starting_thread();

 protected:

  // OS data associated with the thread

  OSThread* _osthread;  // Platform-specific thread information

  // Thread local resource area for temporary allocation within the VM

  ResourceArea* _resource_area;

  // Thread local handle area for allocation of handles within the VM

  HandleArea* _handle_area;

  // Support for stack overflow handling, get_thread, etc.

  address          _stack_base;

  size_t           _stack_size;

  uintptr_t        _self_raw_id;      // used by get_thread (mutable)

  int              _lgrp_id;

 public:

  // Stack overflow support

  address stack_base() const           { assert(_stack_base != NULL,"Sanity check"); return _stack_base; }

  void    set_stack_base(address base) { _stack_base = base; }

  size_t  stack_size() const           { return _stack_size; }

  void    set_stack_size(size_t size)  { _stack_size = size; }

  void    record_stack_base_and_size();

  int     lgrp_id() const                 { return _lgrp_id; }

  void    set_lgrp_id(int value)          { _lgrp_id = value; }

  // Printing

  void print_on(outputStream* st) const;

  void print() const { print_on(tty); }

  virtual void print_on_error(outputStream* st, char* buf, int buflen) const;

  // Debug-only code

#ifdef ASSERT

 private:

  // Deadlock detection support for Mutex locks. List of locks own by thread.

  Monitor *_owned_locks;

  // Mutex::set_owner_implementation is the only place where _owned_locks is modified,

  // thus the friendship

  friend class Mutex;

  friend class Monitor;

 public:

  void print_owned_locks_on(outputStream* st) const;

  void print_owned_locks() const                 { print_owned_locks_on(tty);    }

  Monitor * owned_locks() const                  { return _owned_locks;          }

  bool owns_locks() const                        { return owned_locks() != NULL; }

  bool owns_locks_but_compiled_lock() const;

  // Deadlock detection

  bool allow_allocation()                        { return _allow_allocation_count == 0; }

#endif

  void check_for_valid_safepoint_state(bool potential_vm_operation) PRODUCT_RETURN;

 private:

  volatile int _jvmti_env_iteration_count;

 public:

  void entering_jvmti_env_iteration()            { ++_jvmti_env_iteration_count; }

  void leaving_jvmti_env_iteration()             { --_jvmti_env_iteration_count; }

  bool is_inside_jvmti_env_iteration()           { return _jvmti_env_iteration_count > 0; }

  // Code generation

  static ByteSize exception_file_offset()        { return byte_offset_of(Thread, _exception_file   ); }

  static ByteSize exception_line_offset()        { return byte_offset_of(Thread, _exception_line   ); }

  static ByteSize active_handles_offset()        { return byte_offset_of(Thread, _active_handles   ); }

  static ByteSize stack_base_offset()            { return byte_offset_of(Thread, _stack_base ); }

  static ByteSize stack_size_offset()            { return byte_offset_of(Thread, _stack_size ); }

  static ByteSize omFreeList_offset()            { return byte_offset_of(Thread, omFreeList); }

#define TLAB_FIELD_OFFSET(name) \

  static ByteSize tlab_##name##_offset()            { return byte_offset_of(Thread, _tlab) + ThreadLocalAllocBuffer::name##_offset(); }

  TLAB_FIELD_OFFSET(start)

  TLAB_FIELD_OFFSET(end)

  TLAB_FIELD_OFFSET(top)

  TLAB_FIELD_OFFSET(pf_top)

  TLAB_FIELD_OFFSET(size)                   // desired_size

  TLAB_FIELD_OFFSET(refill_waste_limit)

  TLAB_FIELD_OFFSET(number_of_refills)

  TLAB_FIELD_OFFSET(fast_refill_waste)

  TLAB_FIELD_OFFSET(slow_allocations)

#undef TLAB_FIELD_OFFSET

 public:

  volatile intptr_t _Stalled ;

  volatile int _TypeTag ;

  ParkEvent * _ParkEvent ;                     // for synchronized()

  ParkEvent * _SleepEvent ;                    // for Thread.sleep

  ParkEvent * _MutexEvent ;                    // for native internal Mutex/Monitor

  ParkEvent * _MuxEvent ;                      // for low-level muxAcquire-muxRelease

  int NativeSyncRecursion ;                    // diagnostic

  volatile int _OnTrap ;                       // Resume-at IP delta

  jint _hashStateW ;                           // Marsaglia Shift-XOR thread-local RNG

  jint _hashStateX ;                           // thread-specific hashCode generator state

  jint _hashStateY ;

  jint _hashStateZ ;