src/hotspot/share/runtime/thread.hpp

@@ -27,11 +27,10 @@
 
 #include "jni.h"
 #include "gc/shared/gcThreadLocalData.hpp"
 #include "gc/shared/threadLocalAllocBuffer.hpp"
 #include "memory/allocation.hpp"
-#include "memory/vtBuffer.hpp"
 #include "oops/oop.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/frame.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/handshake.hpp"

@@ -382,20 +381,11 @@
  public:
   enum {
     is_definitely_current_thread = true
   };
 
- private:
-  friend class BufferedValuesDealiaser;
-
-  BufferedValuesDealiaser* _buffered_values_dealiaser;
  public:
-  BufferedValuesDealiaser* buffered_values_dealiaser() {
-    assert(Thread::current() == this, "Should only be accessed locally");
-    return _buffered_values_dealiaser;
-  }
-
   // Constructor
   Thread();
   virtual ~Thread() = 0;        // Thread is abstract.
 
   // Manage Thread::current()

@@ -1127,23 +1117,10 @@
   // 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;
 
-  // Buffered value types support
-  void* _vt_alloc_ptr;
-  void* _vt_alloc_limit;
-  VTBufferChunk* _local_free_chunk;
-  VTBuffer::Mark _current_vtbuffer_mark;
-  // Next 4 fields are used to monitor VT buffer memory consumption
-  // We may want to not support them in PRODUCT builds
-  jint _vtchunk_in_use;
-  jint _vtchunk_max;
-  jint _vtchunk_total_returned;
-  jint _vtchunk_total_failed;
-  jlong _vtchunk_total_memory_buffered;
-
 #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;

@@ -1842,11 +1819,10 @@
   void print_value();
   void print_thread_state_on(outputStream*) const      PRODUCT_RETURN;
   void print_thread_state() const                      PRODUCT_RETURN;
   void print_on_error(outputStream* st, char* buf, int buflen) const;
   void print_name_on_error(outputStream* st, char* buf, int buflen) const;
-  void print_vt_buffer_stats_on(outputStream* st) const;
   void verify();
   const char* get_thread_name() const;
  private:
   // factor out low-level mechanics for use in both normal and error cases
   const char* get_thread_name_string(char* buf = NULL, int buflen = 0) const;

@@ -2024,43 +2000,10 @@
   }
   static inline void set_stack_size_at_create(size_t value) {
     _stack_size_at_create = value;
   }
 
-  void* vt_alloc_ptr() const { return _vt_alloc_ptr; }
-  void set_vt_alloc_ptr(void* ptr) { _vt_alloc_ptr = ptr; }
-  void* vt_alloc_limit() const { return _vt_alloc_limit; }
-  void set_vt_alloc_limit(void* ptr) { _vt_alloc_limit = ptr; }
-  VTBufferChunk* local_free_chunk() const { return _local_free_chunk; }
-  void set_local_free_chunk(VTBufferChunk* chunk) { _local_free_chunk = chunk; }
-  VTBufferChunk* current_chunk() {
-    if (_vt_alloc_ptr == NULL) return NULL;
-    VTBufferChunk* chunk = VTBufferChunk::chunk(_vt_alloc_ptr);
-    assert(chunk->owner() == this, "Sanity check");
-    return chunk;
-    // return _vt_alloc_ptr == NULL ? NULL : VTBufferChunk::chunk(_vt_alloc_ptr);
-  }
-  VTBuffer::Mark current_vtbuffer_mark() const { return _current_vtbuffer_mark; }
-  void set_current_vtbuffer_mark(VTBuffer::Mark m) { _current_vtbuffer_mark = m ; }
-
-  void increment_vtchunk_in_use() {
-    _vtchunk_in_use++;
-    if (_vtchunk_in_use > _vtchunk_max) _vtchunk_max = _vtchunk_in_use;
-  }
-  void decrement_vtchunk_in_use() { _vtchunk_in_use--; }
-  jint vtchunk_in_use() const { return _vtchunk_in_use; }
-  jint vtchunk_max() const { return _vtchunk_max; }
-  void increment_vtchunk_returned() { _vtchunk_total_returned++; }
-  jint vtchunk_total_returned() const { return _vtchunk_total_returned; }
-  void increment_vtchunk_failed() { _vtchunk_total_failed++; }
-  jint vtchunk_total_failed() const { return _vtchunk_total_failed; }
-  void increment_vtchunk_total_memory_buffered(jlong size) { _vtchunk_total_memory_buffered += size; }
-  jlong vtchunk_total_memory_buffered() const { return _vtchunk_total_memory_buffered; }
-
-  static ByteSize vt_alloc_ptr_offset() { return byte_offset_of(JavaThread, _vt_alloc_ptr); }
-
-
   // Machine dependent stuff
 #include OS_CPU_HEADER(thread)
 
  public:
   void set_blocked_on_compilation(bool value) {

@@ -2299,11 +2242,10 @@
   }
   static void print_on_error(outputStream* st, Thread* current, char* buf, int buflen);
   static void print_on_error(Thread* this_thread, outputStream* st, Thread* current, char* buf,
                              int buflen, bool* found_current);
   static void print_threads_compiling(outputStream* st, char* buf, int buflen);
-  static void print_vt_buffer_stats_on(outputStream* st);
 
   // Get Java threads that are waiting to enter a monitor.
   static GrowableArray<JavaThread*>* get_pending_threads(ThreadsList * t_list,
                                                          int count, address monitor);