src/share/vm/logging/logMessageBuffer.cpp

rev 10536 : [mq]: 8145934.alternative
rev 10537 : [mq]: 8145934.02

@@ -25,57 +25,47 @@
 #include "logging/logMessageBuffer.hpp"
 #include "memory/allocation.inline.hpp"
 #include "runtime/thread.inline.hpp"
 
 template <typename T>
-static void grow(T*& buffer, size_t& capacity, bool c_heap, size_t minimum_length = 0) {
+static void grow(T*& buffer, size_t& capacity, size_t minimum_length = 0) {
   size_t new_size = capacity * 2;
   if (new_size < minimum_length) {
     new_size = minimum_length;
   }
-  if (c_heap) {
     buffer = REALLOC_C_HEAP_ARRAY(T, buffer, new_size, mtLogging);
-  } else {
-    buffer = REALLOC_RESOURCE_ARRAY(T, buffer, capacity, new_size);
-  }
   capacity = new_size;
 }
 
 LogMessageBuffer::LogMessageBuffer() : _message_buffer_size(0),
                                        _message_buffer_capacity(0),
                                        _message_buffer(NULL),
                                        _line_count(0),
                                        _line_capacity(0),
                                        _lines(NULL),
-                                       _c_heap_allocated(Thread::current_or_null() == NULL),
+                                       _allocated(false),
                                        _least_detailed_level(LogLevel::Off),
                                        _prefix_fn(NULL) {
 }
 
 LogMessageBuffer::~LogMessageBuffer() {
-  if (_c_heap_allocated) {
+  if (_allocated) {
     FREE_C_HEAP_ARRAY(char, _message_buffer);
     FREE_C_HEAP_ARRAY(LogLine, _lines);
-  } else {
-    FREE_RESOURCE_ARRAY(char, _message_buffer, _message_buffer_capacity);
-    FREE_RESOURCE_ARRAY(LogLine, _lines, _line_capacity);
   }
 }
 
-void LogMessageBuffer::clear() {
+void LogMessageBuffer::reset() {
   _message_buffer_size = 0;
   _line_count = 0;
 }
 
 void LogMessageBuffer::initialize_buffers() {
-  if (_c_heap_allocated) {
+  assert(!_allocated, "buffer already initialized/allocated");
+  _allocated = true;
     _message_buffer = NEW_C_HEAP_ARRAY(char, InitialMessageBufferCapacity, mtLogging);
     _lines = NEW_C_HEAP_ARRAY(LogLine, InitialLineCapacity, mtLogging);
-  } else {
-    _message_buffer = NEW_RESOURCE_ARRAY(char, InitialMessageBufferCapacity);
-    _lines = NEW_RESOURCE_ARRAY(LogLine, InitialLineCapacity);
-  }
   _message_buffer_capacity = InitialMessageBufferCapacity;
   _line_capacity = InitialLineCapacity;
 }
 
 void LogMessageBuffer::Iterator::skip_messages_with_finer_level() {

@@ -92,11 +82,11 @@
   vwrite(level, fmt, args);
   va_end(args);
 };
 
 void LogMessageBuffer::vwrite(LogLevelType level, const char* fmt, va_list args) {
-  if (_message_buffer_capacity == 0) {
+  if (!_allocated) {
     initialize_buffers();
   }
 
   if (level > _least_detailed_level) {
     _least_detailed_level = level;

@@ -122,18 +112,18 @@
     va_copy(copy, args);
     written += (size_t)os::log_vsnprintf(current_buffer_position, remaining_buffer_length, fmt, copy) + 1;
     va_end(copy);
     if (written > _message_buffer_capacity - _message_buffer_size) {
       assert(attempts == 0, "Second attempt should always have a sufficiently large buffer (resized to fit).");
-      grow(_message_buffer, _message_buffer_capacity, _c_heap_allocated, _message_buffer_size + written);
+      grow(_message_buffer, _message_buffer_capacity, _message_buffer_size + written);
       continue;
     }
     break;
   }
 
   if (_line_count == _line_capacity) {
-    grow(_lines, _line_capacity, _c_heap_allocated);
+    grow(_lines, _line_capacity);
   }
 
   _lines[_line_count].level = level;
   _lines[_line_count].message_offset = _message_buffer_size;
   _message_buffer_size += written;