truffle: src/share/vm/runtime/thread.hpp comparison

comparison src/share/vm/runtime/thread.hpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	8f2fb6bec986 d3f3f7677537
children	be896a1983c0

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "runtime/osThread.hpp"
 #include "runtime/park.hpp"
 #include "runtime/safepoint.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/threadLocalStorage.hpp"
+#include "runtime/thread_ext.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/macros.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
 class jvmtiDeferredLocalVariableSet;
 class GCTaskQueue;
 class ThreadClosure;
 class IdealGraphPrinter;
+class Metadata;
+template <class T, MEMFLAGS F> class ChunkedList;
+typedef ChunkedList<Metadata*, mtInternal> MetadataOnStackBuffer;
 DEBUG_ONLY(class ResourceMark;)
 class WorkerThread;
 ThreadLocalAllocBuffer _tlab;                 // Thread-local eden
 jlong _allocated_bytes;                       // Cumulative number of bytes allocated on
 // the Java heap
+// Thread-local buffer used by MetadataOnStackMark.
+MetadataOnStackBuffer* _metadata_on_stack_buffer;
 TRACE_DATA _trace_data;                       // Thread-local data for tracing
+ThreadExt _ext;
 int   _vm_operation_started_count;            // VM_Operation support
 int   _vm_operation_completed_count;          // VM_Operation support
 ObjectMonitor* _current_pending_monitor;      // ObjectMonitor this thread
 }
 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() {
+inline 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; }
+const ThreadExt& ext() const          { return _ext; }
+ThreadExt& ext()                      { return _ext; }
 // 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++; }
 // 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);
+virtual void oops_do(OopClosure* f, CLDClosure* 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
+// Requires that "collection_parity" is that of the current 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
 // 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:
+void set_metadata_on_stack_buffer(MetadataOnStackBuffer* buffer) { _metadata_on_stack_buffer = buffer; }
+MetadataOnStackBuffer* metadata_on_stack_buffer() const          { return _metadata_on_stack_buffer; }
+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;
 // JVMTI PopFrame support
 // This is set to popframe_pending to signal that top Java frame should be popped immediately
 int _popframe_condition;
+// If reallocation of scalar replaced objects fails, we throw OOM
+// and during exception propagation, pop the top
+// _frames_to_pop_failed_realloc frames, the ones that reference
+// failed reallocations.
+int _frames_to_pop_failed_realloc;
 #ifndef PRODUCT
 int _jmp_ring_index;
 struct {
 // We use intptr_t instead of address so debugger doesn't try and display strings
 intptr_t _target;
 // Prepare thread and add to priority queue.  If a priority is
 // not specified, use the priority of the thread object. Threads_lock
 // must be held while this function is called.
 void prepare(jobject jni_thread, ThreadPriority prio=NoPriority);
+void prepare_ext();
 void set_saved_exception_pc(address pc)        { _saved_exception_pc = pc; }
 address saved_exception_pc()                   { return _saved_exception_pc; }
 JavaThreadState thread_state() const           { return _thread_state; }
 void set_thread_state(JavaThreadState s)       { _thread_state = s;    }
 #else
 // Use membars when accessing volatile _thread_state. See
 // Threads::create_vm() for size checks.
-JavaThreadState thread_state() const           {
+inline JavaThreadState thread_state() const;
-return (JavaThreadState) OrderAccess::load_acquire((volatile jint*)&_thread_state);
+inline void set_thread_state(JavaThreadState s);
-}
-void set_thread_state(JavaThreadState s)       {
-OrderAccess::release_store((volatile jint*)&_thread_state, (jint)s);
-}
 #endif
 ThreadSafepointState *safepoint_state() const  { return _safepoint_state; }
 void set_safepoint_state(ThreadSafepointState *state) { _safepoint_state = state; }
 bool is_at_poll_safepoint()                    { return _safepoint_state->is_at_poll_safepoint(); }
 bool doing_unsafe_access()                     { return _doing_unsafe_access; }
 void set_doing_unsafe_access(bool val)         { _doing_unsafe_access = val; }
 bool do_not_unlock_if_synchronized()             { return _do_not_unlock_if_synchronized; }
 void set_do_not_unlock_if_synchronized(bool val) { _do_not_unlock_if_synchronized = val; }
-#if INCLUDE_NMT
-// native memory tracking
-inline MemRecorder* get_recorder() const          { return (MemRecorder*)_recorder; }
-inline void         set_recorder(MemRecorder* rc) { _recorder = rc; }
-private:
-// per-thread memory recorder
-MemRecorder* volatile _recorder;
-#endif // INCLUDE_NMT
 // Suspend/resume support for JavaThread
 private:
 void set_ext_suspended()       { set_suspend_flag (_ext_suspended);  }
 void clear_ext_suspended()     { clear_suspend_flag(_ext_suspended); }
 // Frame iteration; calls the function f for all frames on the stack
 void frames_do(void f(frame*, const RegisterMap*));
 // Memory operations
-void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
+void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
 // Sweeper operations
 void nmethods_do(CodeBlobClosure* cf);
 // RedefineClasses Support
 ThreadProfiler* result = _thread_profiler;
 _thread_profiler = tp;
 return result;
 }
-// NMT (Native memory tracking) support.
-// This flag helps NMT to determine if this JavaThread will be blocked
-// at safepoint. If not, ThreadCritical is needed for writing memory records.
-// JavaThread is only safepoint visible when it is in Threads' thread list,
-// it is not visible until it is added to the list and becomes invisible
-// once it is removed from the list.
-public:
-bool is_safepoint_visible() const { return _safepoint_visible; }
-void set_safepoint_visible(bool visible) { _safepoint_visible = visible; }
-private:
-bool _safepoint_visible;
-// Static operations
 public:
 // Returns the running thread as a JavaThread
 static inline JavaThread* current();
 // Returns the active Java thread.  Do not use this if you know you are calling
 bool pop_frame_in_process(void)                     { return ((_popframe_condition & popframe_processing_bit) != 0); }
 void set_pop_frame_in_process(void)                 { _popframe_condition |= popframe_processing_bit; }
 void clr_pop_frame_in_process(void)                 { _popframe_condition &= ~popframe_processing_bit; }
 #endif
+int frames_to_pop_failed_realloc() const            { return _frames_to_pop_failed_realloc; }
+void set_frames_to_pop_failed_realloc(int nb)       { _frames_to_pop_failed_realloc = nb; }
+void dec_frames_to_pop_failed_realloc()             { _frames_to_pop_failed_realloc--; }
 private:
 // Saved incoming arguments to popped frame.
 // Used only when popped interpreted frame returns to deoptimized frame.
 void*    _popframe_preserved_args;
 int      _popframe_preserved_args_size;
 void set_cached_monitor_info(GrowableArray<MonitorInfo*>* info) { _cached_monitor_info = info; }
 // clearing/querying jni attach status
 bool is_attaching_via_jni() const { return _jni_attach_state == _attaching_via_jni; }
 bool has_attached_via_jni() const { return is_attaching_via_jni() || _jni_attach_state == _attached_via_jni; }
-void set_done_attaching_via_jni() { _jni_attach_state = _attached_via_jni; OrderAccess::fence(); }
+inline void set_done_attaching_via_jni();
 private:
 // This field is used to determine if a thread has claimed
 // a par_id: it is UINT_MAX if the thread has not claimed a par_id;
 // otherwise its value is the par_id that has been claimed.
 uint _claimed_par_id;
 }
 // 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, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
+void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
 #ifndef PRODUCT
 private:
 IdealGraphPrinter *_ideal_graph_printer;
 public:
 // Garbage collection
 static void follow_other_roots(void f(oop*));
 // Apply "f->do_oop" to all root oops in all threads.
 // This version may only be called by sequential code.
-static void oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
+static void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
 // This version may be called by sequential or parallel code.
-static void possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf);
+static void possibly_parallel_oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
 // This creates a list of GCTasks, one per thread.
 static void create_thread_roots_tasks(GCTaskQueue* q);
 // This creates a list of GCTasks, one per thread, for marking objects.
 static void create_thread_roots_marking_tasks(GCTaskQueue* q);
 // Number of non-daemon threads on the active threads list
 static int number_of_non_daemon_threads()      { return _number_of_non_daemon_threads; }
 // Deoptimizes all frames tied to marked nmethods
 static void deoptimized_wrt_marked_nmethods();
+static JavaThread* find_java_thread_from_java_tid(jlong java_tid);
 };
 // Thread iterator

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.hpp @ 20804:7848fc12602b