--- a/hotspot/src/share/vm/services/mallocTracker.hpp	Mon Aug 11 10:18:09 2014 -0700
+++ b/hotspot/src/share/vm/services/mallocTracker.hpp	Wed Aug 20 08:41:15 2014 -0400
@@ -171,8 +171,9 @@
   // Total malloc'd memory used by arenas
   size_t total_arena() const;
 
-  inline size_t thread_count() {
-    return by_type(mtThreadStack)->malloc_count();
+  inline size_t thread_count() const {
+    MallocMemorySnapshot* s = const_cast<MallocMemorySnapshot*>(this);
+    return s->by_type(mtThreadStack)->malloc_count();
   }
 
   void reset();

--- a/hotspot/src/share/vm/services/memBaseline.cpp	Mon Aug 11 10:18:09 2014 -0700
+++ b/hotspot/src/share/vm/services/memBaseline.cpp	Wed Aug 20 08:41:15 2014 -0400
@@ -70,15 +70,13 @@
  */
 class MallocAllocationSiteWalker : public MallocSiteWalker {
  private:
-  SortedLinkedList<MallocSite, compare_malloc_size, ResourceObj::ARENA>
-                 _malloc_sites;
+  SortedLinkedList<MallocSite, compare_malloc_size> _malloc_sites;
   size_t         _count;
 
   // Entries in MallocSiteTable with size = 0 and count = 0,
   // when the malloc site is not longer there.
  public:
-  MallocAllocationSiteWalker(Arena* arena) : _count(0), _malloc_sites(arena) {
-  }
+  MallocAllocationSiteWalker() : _count(0) { }
 
   inline size_t count() const { return _count; }
 
@@ -109,13 +107,12 @@
 // Walk all virtual memory regions for baselining
 class VirtualMemoryAllocationWalker : public VirtualMemoryWalker {
  private:
-  SortedLinkedList<ReservedMemoryRegion, compare_virtual_memory_base, ResourceObj::ARENA>
+  SortedLinkedList<ReservedMemoryRegion, compare_virtual_memory_base>
                 _virtual_memory_regions;
   size_t        _count;
 
  public:
-  VirtualMemoryAllocationWalker(Arena* a) : _count(0), _virtual_memory_regions(a) {
-  }
+  VirtualMemoryAllocationWalker() : _count(0) { }
 
   bool do_allocation_site(const ReservedMemoryRegion* rgn)  {
     if (rgn->size() >= MemBaseline::SIZE_THRESHOLD) {
@@ -136,39 +133,30 @@
 
 
 bool MemBaseline::baseline_summary() {
-  assert(_malloc_memory_snapshot == NULL, "Malloc baseline not yet reset");
-  assert(_virtual_memory_snapshot == NULL, "Virtual baseline not yet reset");
-
-  _malloc_memory_snapshot =  new (arena()) MallocMemorySnapshot();
-  _virtual_memory_snapshot = new (arena()) VirtualMemorySnapshot();
-  if (_malloc_memory_snapshot == NULL || _virtual_memory_snapshot == NULL) {
-    return false;
-  }
-  MallocMemorySummary::snapshot(_malloc_memory_snapshot);
-  VirtualMemorySummary::snapshot(_virtual_memory_snapshot);
+  MallocMemorySummary::snapshot(&_malloc_memory_snapshot);
+  VirtualMemorySummary::snapshot(&_virtual_memory_snapshot);
   return true;
 }
 
 bool MemBaseline::baseline_allocation_sites() {
-  assert(arena() != NULL, "Just check");
   // Malloc allocation sites
-  MallocAllocationSiteWalker malloc_walker(arena());
+  MallocAllocationSiteWalker malloc_walker;
   if (!MallocSiteTable::walk_malloc_site(&malloc_walker)) {
     return false;
   }
 
-  _malloc_sites.set_head(malloc_walker.malloc_sites()->head());
+  _malloc_sites.move(malloc_walker.malloc_sites());
   // The malloc sites are collected in size order
   _malloc_sites_order = by_size;
 
   // Virtual memory allocation sites
-  VirtualMemoryAllocationWalker virtual_memory_walker(arena());
+  VirtualMemoryAllocationWalker virtual_memory_walker;
   if (!VirtualMemoryTracker::walk_virtual_memory(&virtual_memory_walker)) {
     return false;
   }
 
   // Virtual memory allocations are collected in call stack order
-  _virtual_memory_allocations.set_head(virtual_memory_walker.virtual_memory_allocations()->head());
+  _virtual_memory_allocations.move(virtual_memory_walker.virtual_memory_allocations());
 
   if (!aggregate_virtual_memory_allocation_sites()) {
     return false;
@@ -180,11 +168,6 @@
 }
 
 bool MemBaseline::baseline(bool summaryOnly) {
-  if (arena() == NULL) {
-    _arena = new (std::nothrow, mtNMT) Arena(mtNMT);
-    if (arena() == NULL) return false;
-  }
-
   reset();
 
   _class_count = InstanceKlass::number_of_instance_classes();
@@ -211,8 +194,7 @@
 }
 
 bool MemBaseline::aggregate_virtual_memory_allocation_sites() {
-  SortedLinkedList<VirtualMemoryAllocationSite, compare_allocation_site, ResourceObj::ARENA>
-    allocation_sites(arena());
+  SortedLinkedList<VirtualMemoryAllocationSite, compare_allocation_site> allocation_sites;
 
   VirtualMemoryAllocationIterator itr = virtual_memory_allocations();
   const ReservedMemoryRegion* rgn;
@@ -230,12 +212,12 @@
     site->commit_memory(rgn->committed_size());
   }
 
-  _virtual_memory_sites.set_head(allocation_sites.head());
+  _virtual_memory_sites.move(&allocation_sites);
   return true;
 }
 
 MallocSiteIterator MemBaseline::malloc_sites(SortingOrder order) {
-  assert(!_malloc_sites.is_empty(), "Detail baseline?");
+  assert(!_malloc_sites.is_empty(), "Not detail baseline");
   switch(order) {
     case by_size:
       malloc_sites_to_size_order();
@@ -251,7 +233,7 @@
 }
 
 VirtualMemorySiteIterator MemBaseline::virtual_memory_sites(SortingOrder order) {
-  assert(!_virtual_memory_sites.is_empty(), "Detail baseline?");
+  assert(!_virtual_memory_sites.is_empty(), "Not detail baseline");
   switch(order) {
     case by_size:
       virtual_memory_sites_to_size_order();
@@ -270,8 +252,7 @@
 // Sorting allocations sites in different orders
 void MemBaseline::malloc_sites_to_size_order() {
   if (_malloc_sites_order != by_size) {
-    SortedLinkedList<MallocSite, compare_malloc_size, ResourceObj::ARENA>
-      tmp(arena());
+    SortedLinkedList<MallocSite, compare_malloc_size> tmp;
 
     // Add malloc sites to sorted linked list to sort into size order
     tmp.move(&_malloc_sites);
@@ -283,8 +264,7 @@
 
 void MemBaseline::malloc_sites_to_allocation_site_order() {
   if (_malloc_sites_order != by_site) {
-    SortedLinkedList<MallocSite, compare_malloc_site, ResourceObj::ARENA>
-      tmp(arena());
+    SortedLinkedList<MallocSite, compare_malloc_site> tmp;
     // Add malloc sites to sorted linked list to sort into site (address) order
     tmp.move(&_malloc_sites);
     _malloc_sites.set_head(tmp.head());
@@ -295,8 +275,7 @@
 
 void MemBaseline::virtual_memory_sites_to_size_order() {
   if (_virtual_memory_sites_order != by_size) {
-    SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_size, ResourceObj::ARENA>
-      tmp(arena());
+    SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_size> tmp;
 
     tmp.move(&_virtual_memory_sites);
 
@@ -308,10 +287,9 @@
 
 void MemBaseline::virtual_memory_sites_to_reservation_site_order() {
   if (_virtual_memory_sites_order != by_size) {
-    SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_site, ResourceObj::ARENA>
-      tmp(arena());
+    SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_site> tmp;
 
-    tmp.add(&_virtual_memory_sites);
+    tmp.move(&_virtual_memory_sites);
 
     _virtual_memory_sites.set_head(tmp.head());
     tmp.set_head(NULL);

--- a/hotspot/src/share/vm/services/memBaseline.hpp	Mon Aug 11 10:18:09 2014 -0700
+++ b/hotspot/src/share/vm/services/memBaseline.hpp	Wed Aug 20 08:41:15 2014 -0400
@@ -61,28 +61,22 @@
   };
 
  private:
-  // All baseline data is stored in this arena
-  Arena*                  _arena;
-
   // Summary information
-  MallocMemorySnapshot*   _malloc_memory_snapshot;
-  VirtualMemorySnapshot*  _virtual_memory_snapshot;
+  MallocMemorySnapshot   _malloc_memory_snapshot;
+  VirtualMemorySnapshot  _virtual_memory_snapshot;
 
   size_t               _class_count;
 
   // Allocation sites information
   // Malloc allocation sites
-  LinkedListImpl<MallocSite, ResourceObj::ARENA>
-                       _malloc_sites;
+  LinkedListImpl<MallocSite>                  _malloc_sites;
 
   // All virtual memory allocations
-  LinkedListImpl<ReservedMemoryRegion, ResourceObj::ARENA>
-                       _virtual_memory_allocations;
+  LinkedListImpl<ReservedMemoryRegion>        _virtual_memory_allocations;
 
   // Virtual memory allocations by allocation sites, always in by_address
   // order
-  LinkedListImpl<VirtualMemoryAllocationSite, ResourceObj::ARENA>
-                       _virtual_memory_sites;
+  LinkedListImpl<VirtualMemoryAllocationSite> _virtual_memory_sites;
 
   SortingOrder         _malloc_sites_order;
   SortingOrder         _virtual_memory_sites_order;
@@ -93,30 +87,23 @@
   // create a memory baseline
   MemBaseline():
     _baseline_type(Not_baselined),
-    _class_count(0),
-    _arena(NULL),
-    _malloc_memory_snapshot(NULL),
-    _virtual_memory_snapshot(NULL),
-    _malloc_sites(NULL) {
+    _class_count(0) {
   }
 
   ~MemBaseline() {
     reset();
-    if (_arena != NULL) {
-      delete _arena;
-    }
   }
 
   bool baseline(bool summaryOnly = true);
 
   BaselineType baseline_type() const { return _baseline_type; }
 
-  MallocMemorySnapshot* malloc_memory_snapshot() const {
-    return _malloc_memory_snapshot;
+  MallocMemorySnapshot* malloc_memory_snapshot() {
+    return &_malloc_memory_snapshot;
   }
 
-  VirtualMemorySnapshot* virtual_memory_snapshot() const {
-    return _virtual_memory_snapshot;
+  VirtualMemorySnapshot* virtual_memory_snapshot() {
+    return &_virtual_memory_snapshot;
   }
 
   MallocSiteIterator malloc_sites(SortingOrder order);
@@ -133,10 +120,8 @@
   // memory
   size_t total_reserved_memory() const {
     assert(baseline_type() != Not_baselined, "Not yet baselined");
-    assert(_virtual_memory_snapshot != NULL, "No virtual memory snapshot");
-    assert(_malloc_memory_snapshot != NULL,  "No malloc memory snapshot");
-    size_t amount = _malloc_memory_snapshot->total() +
-           _virtual_memory_snapshot->total_reserved();
+    size_t amount = _malloc_memory_snapshot.total() +
+           _virtual_memory_snapshot.total_reserved();
     return amount;
   }
 
@@ -144,32 +129,30 @@
   // virtual memory
   size_t total_committed_memory() const {
     assert(baseline_type() != Not_baselined, "Not yet baselined");
-    assert(_virtual_memory_snapshot != NULL,
-      "Not a snapshot");
-    size_t amount = _malloc_memory_snapshot->total() +
-           _virtual_memory_snapshot->total_committed();
+    size_t amount = _malloc_memory_snapshot.total() +
+           _virtual_memory_snapshot.total_committed();
     return amount;
   }
 
   size_t total_arena_memory() const {
     assert(baseline_type() != Not_baselined, "Not yet baselined");
-    assert(_malloc_memory_snapshot != NULL, "Not yet baselined");
-    return _malloc_memory_snapshot->total_arena();
+    return _malloc_memory_snapshot.total_arena();
   }
 
   size_t malloc_tracking_overhead() const {
     assert(baseline_type() != Not_baselined, "Not yet baselined");
-    return _malloc_memory_snapshot->malloc_overhead()->size();
+    MemBaseline* bl = const_cast<MemBaseline*>(this);
+    return bl->_malloc_memory_snapshot.malloc_overhead()->size();
   }
 
-  const MallocMemory* malloc_memory(MEMFLAGS flag) const {
-    assert(_malloc_memory_snapshot != NULL, "Not a snapshot");
-    return _malloc_memory_snapshot->by_type(flag);
+  MallocMemory* malloc_memory(MEMFLAGS flag) {
+    assert(baseline_type() != Not_baselined, "Not yet baselined");
+    return _malloc_memory_snapshot.by_type(flag);
   }
 
-  const VirtualMemory* virtual_memory(MEMFLAGS flag) const {
-    assert(_virtual_memory_snapshot != NULL, "Not a snapshot");
-    return _virtual_memory_snapshot->by_type(flag);
+  VirtualMemory* virtual_memory(MEMFLAGS flag) {
+    assert(baseline_type() != Not_baselined, "Not yet baselined");
+    return _virtual_memory_snapshot.by_type(flag);
   }
 
 
@@ -180,24 +163,19 @@
 
   size_t thread_count() const {
     assert(baseline_type() != Not_baselined, "Not yet baselined");
-    assert(_malloc_memory_snapshot != NULL, "Baselined?");
-    return _malloc_memory_snapshot->thread_count();
+    return _malloc_memory_snapshot.thread_count();
   }
 
   // reset the baseline for reuse
   void reset() {
     _baseline_type = Not_baselined;
-    _malloc_memory_snapshot = NULL;
-    _virtual_memory_snapshot = NULL;
+    _malloc_memory_snapshot.reset();
+    _virtual_memory_snapshot.reset();
     _class_count  = 0;
 
-    _malloc_sites = NULL;
-    _virtual_memory_sites = NULL;
-    _virtual_memory_allocations = NULL;
-
-    if (_arena != NULL) {
-      _arena->destruct_contents();
-    }
+    _malloc_sites.clear();
+    _virtual_memory_sites.clear();
+    _virtual_memory_allocations.clear();
   }
 
  private:
@@ -210,8 +188,6 @@
   // Aggregate virtual memory allocation by allocation sites
   bool aggregate_virtual_memory_allocation_sites();
 
-  Arena* arena() { return _arena; }
-
   // Sorting allocation sites in different orders
   // Sort allocation sites in size order
   void malloc_sites_to_size_order();