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

comparison src/share/vm/runtime/thread.hpp @ 7066:7d815d842ee0

Merge.

author	Christian Haeubl <haeubl@ssw.jku.at>
date	Fri, 23 Nov 2012 11:50:27 +0100
parents	679e6584c177
children	291ffc492eb6

comparison

equal deleted inserted replaced

-:cfacf5d5bade
+:7d815d842ee0
 #include "runtime/park.hpp"
 #include "runtime/safepoint.hpp"
 #include "runtime/stubRoutines.hpp"
 #include "runtime/threadLocalStorage.hpp"
 #include "runtime/unhandledOops.hpp"
+#if INCLUDE_NMT
 #include "services/memRecorder.hpp"
+#endif // INCLUDE_NMT
 #include "trace/tracing.hpp"
 #include "utilities/exceptions.hpp"
 #include "utilities/top.hpp"
 #ifndef SERIALGC
 #include "gc_implementation/g1/dirtyCardQueue.hpp"
 protected:
 // Support for forcing alignment of thread objects for biased locking
 void*       _real_malloc_address;
 public:
 void* operator new(size_t size) { return allocate(size, true); }
-void* operator new(size_t size, std::nothrow_t& nothrow_constant) { return allocate(size, false); }
+void* operator new(size_t size, const std::nothrow_t& nothrow_constant) { return allocate(size, false); }
 void  operator delete(void* p);
 protected:
 static void* allocate(size_t size, bool throw_excpt, MEMFLAGS flags = mtThread);
 private:
 // 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();
 }
 // Sweeper support
 void nmethods_do(CodeBlobClosure* cf);
+// jvmtiRedefineClasses support
+void metadata_do(void f(Metadata*));
 // 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
 // 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;
+GrowableArray<Metadata*>* _metadata_handles;
 // 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)
 virtual void run();
 private:
 static WatcherThread* _watcher_thread;
+static bool _startable;
 volatile static bool _should_terminate; // updated without holding lock
 public:
 enum SomeConstants {
 delay_interval = 10                          // interrupt delay in milliseconds
 };
 // Printing
 char* name() const { return (char*)"VM Periodic Task Thread"; }
 void print_on(outputStream* st) const;
 void print() const { print_on(tty); }
+void unpark();
 // Returns the single instance of WatcherThread
 static WatcherThread* watcher_thread()         { return _watcher_thread; }
 // Create and start the single instance of WatcherThread, or stop it on shutdown
 static void start();
 static void stop();
+// Only allow start once the VM is sufficiently initialized
+// Otherwise the first task to enroll will trigger the start
+static void make_startable();
+private:
+int sleep() const;
 };
 class CompilerThread;
 friend class VMStructs;
 private:
 JavaThread*    _next;                          // The next thread in the Threads list
 oop            _threadObj;                     // The Java level thread object
-// (thomaswue) Necessary for holding a compilation buffer and ci environment. Moved from CompilerThread to JavaThread in order to enable code installation from Java application code.
+// (thomaswue) Necessary for holding a compilation buffer and ci environment.
+// Moved up from CompilerThread to JavaThread in order to enable code
+// installation from Java application code.
 BufferBlob*   _buffer_blob;
 ciEnv*        _env;
 bool          _is_compiling;
 #ifdef ASSERT
 // This holds the pointer to array (yeah like there might be more than one) of
 // description of compiled vframes that have locals that need to be updated.
 GrowableArray<jvmtiDeferredLocalVariableSet*>* _deferred_locals_updates;
 // Handshake value for fixing 6243940. We need a place for the i2c
-// adapter to store the callee methodOop. This value is NEVER live
+// adapter to store the callee Method*. This value is NEVER live
 // across a gc point so it does NOT have to be gc'd
 // The handshake is open ended since we can't be certain that it will
 // be NULLed. This is because we rarely ever see the race and end up
 // in handle_wrong_method which is the backend of the handshake. See
 // code in i2c adapters and handle_wrong_method.
-methodOop     _callee_target;
+Method*       _callee_target;
-// Oop results of VM runtime calls
+// Used to pass back results to the interpreter or generated code running Java code.
-oop           _vm_result;    // Used to pass back an oop result into Java code, GC-preserved
+oop           _vm_result;    // oop result is GC-preserved
-oop           _vm_result_2;  // Used to pass back an oop result into Java code, GC-preserved
+Metadata*     _vm_result_2;  // non-oop result
 // See ReduceInitialCardMarks: this holds the precise space interval of
 // the most recent slow path allocation for which compiled code has
 // elided card-marks for performance along the fast-path.
 MemRegion     _deferred_card_mark;
 };
 private:
 #ifdef GRAAL
-// graal needs some place to put the dimensions
-jint _graal_multinewarray_storage[256];
 volatile oop _graal_deopt_info;
 address _graal_alternate_call_target;
+DebugScopedValue* _debug_scope;
 #endif
 #ifdef HIGH_LEVEL_INTERPRETER
 bool _high_level_interpreter_in_vm;
 #endif
 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 = (volatile MemRecorder*)rc; }
 private:
 // per-thread memory recorder
 volatile MemRecorder* _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); }
 void     clear_must_deopt_id()                 { _must_deopt_id = NULL; }
 void set_deopt_nmethod(nmethod* nm)            { _deopt_nmethod = nm;   }
 nmethod* deopt_nmethod()                       { return _deopt_nmethod; }
-methodOop  callee_target() const               { return _callee_target; }
+Method*    callee_target() const               { return _callee_target; }
-void set_callee_target  (methodOop x)          { _callee_target   = x; }
+void set_callee_target  (Method* x)          { _callee_target   = x; }
 // Oop results of vm runtime calls
 oop  vm_result() const                         { return _vm_result; }
 void set_vm_result  (oop x)                    { _vm_result   = x; }
-oop  vm_result_2() const                       { return _vm_result_2; }
+Metadata*    vm_result_2() const               { return _vm_result_2; }
-void set_vm_result_2  (oop x)                  { _vm_result_2   = x; }
+void set_vm_result_2  (Metadata* x)          { _vm_result_2   = x; }
 MemRegion deferred_card_mark() const           { return _deferred_card_mark; }
 void set_deferred_card_mark(MemRegion mr)      { _deferred_card_mark = mr;   }
 #ifdef GRAAL
 oop      graal_deopt_info() const              { return _graal_deopt_info; }
 void set_graal_deopt_info(oop o)               { _graal_deopt_info = o; }
 void set_graal_alternate_call_target(address a) { _graal_alternate_call_target = a; }
+DebugScopedValue* debug_scope() const                { return _debug_scope; }
+void set_debug_scope(DebugScopedValue* ds)           { _debug_scope = ds; }
 #endif
 #ifdef HIGH_LEVEL_INTERPRETER
 bool high_level_interpreter_in_vm()            { return _high_level_interpreter_in_vm; }
 void set_high_level_interpreter_in_vm(bool value) { _high_level_interpreter_in_vm = value; }
 #endif
 static ByteSize saved_exception_pc_offset()    { return byte_offset_of(JavaThread, _saved_exception_pc  ); }
 static ByteSize osthread_offset()              { return byte_offset_of(JavaThread, _osthread            ); }
 #ifdef GRAAL
 static ByteSize graal_deopt_info_offset()      { return byte_offset_of(JavaThread, _graal_deopt_info    ); }
 static ByteSize graal_alternate_call_target_offset() { return byte_offset_of(JavaThread, _graal_alternate_call_target); }
-static ByteSize graal_multinewarray_storage_offset() { return byte_offset_of(JavaThread, _graal_multinewarray_storage); }
 #endif
 #ifdef HIGH_LEVEL_INTERPRETER
 static ByteSize high_level_interpreter_in_vm_offset() { return byte_offset_of(JavaThread, _high_level_interpreter_in_vm); }
 #endif
 static ByteSize exception_oop_offset()         { return byte_offset_of(JavaThread, _exception_oop       ); }
 // Memory operations
 void oops_do(OopClosure* f, CodeBlobClosure* cf);
 // Sweeper operations
 void nmethods_do(CodeBlobClosure* cf);
+// RedefineClasses Support
+void metadata_do(void f(Metadata*));
 // Memory management operations
 void gc_epilogue();
 void gc_prologue();
 }
 javaVFrame* last_java_vframe(RegisterMap* reg_map);
 // Returns method at 'depth' java or native frames down the stack
 // Used for security checks
-klassOop security_get_caller_class(int depth);
+Klass* security_get_caller_class(int depth);
 // Print stack trace in external format
 void print_stack_on(outputStream* st);
 void print_stack() { print_stack_on(tty); }
 private:
 static JavaThread* _thread_list;
 static int         _number_of_threads;
 static int         _number_of_non_daemon_threads;
 static int         _return_code;
+#ifdef ASSERT
+static bool        _vm_complete;
+#endif
 public:
 // Thread management
 // force_daemon is a concession to JNI, where we may need to add a
 // thread to the thread list before allocating its thread object
 static void restore_hcode_pointers();
 // Sweeper
 static void nmethods_do(CodeBlobClosure* cf);
+// RedefineClasses support
+static void metadata_do(void f(Metadata*));
 static void gc_epilogue();
 static void gc_prologue();
+#ifdef ASSERT
+static bool is_vm_complete() { return _vm_complete; }
+#endif
 // Verification
 static void verify();
 static void print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks);
 static void print(bool print_stacks, bool internal_format) {

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.hpp @ 7066:7d815d842ee0