commit bbd695c71e0bf518f582e84524e1cdeb3de3896c
author Mathieu Chartier <mathieuc@google.com> Wed Apr 16 09:48:48 2014 -0700
committer Mathieu Chartier <mathieuc@google.com> Thu Apr 17 19:01:34 2014 -0700
tree 6fe6a128b629abc6a396a192b2e8da1180afeded
parent a092ee404ababbf8fc945111dc4a571284c9f02f

Replace ObjectSet with LargeObjectBitmap.

Speeds up large object marking since large objects no longer required
a lock. Changed the GCs to use the heap bitmap for marking objects
which aren't in the fast path. This eliminates the need for a
MarkLargeObject function.

Maps before (10 GC iterations):
Mean partial time: 180ms
Mean sticky time: 151ms

Maps after:
Mean partial time: 161ms
Mean sticky time: 101ms

Note: the GC durations are long due to recent ergonomic changes and
because the fast bulk free hasn't yet been enabled. Over 50% of the
GC time is spent in RosAllocSpace::FreeList.

Bug: 13571028

Change-Id: Id8f94718aeaa13052672ccbae1e8edf77d653f62

runtime/gc/space/large_object_space.h

diff --git a/runtime/gc/space/large_object_space.h b/runtime/gc/space/large_object_space.h
index 18e518f..0daefba 100644
--- a/runtime/gc/space/large_object_space.h
+++ b/runtime/gc/space/large_object_space.h
@@ -49,11 +49,11 @@
     return num_objects_allocated_;
   }
 
-  uint64_t GetTotalBytesAllocated() {
+  uint64_t GetTotalBytesAllocated() const {
     return total_bytes_allocated_;
   }
 
-  uint64_t GetTotalObjectsAllocated() {
+  uint64_t GetTotalObjectsAllocated() const {
     return total_objects_allocated_;
   }
 
@@ -73,20 +73,36 @@
     return this;
   }
 
-  void Sweep(bool swap_bitmaps, size_t* freed_objects, size_t* freed_bytes);
+  void Sweep(bool swap_bitmaps, size_t* out_freed_objects, size_t* out_freed_bytes);
 
   virtual bool CanMoveObjects() const OVERRIDE {
     return false;
   }
 
+  // Current address at which the space begins, which may vary as the space is filled.
+  byte* Begin() const {
+    return begin_;
+  }
+
+  // Current address at which the space ends, which may vary as the space is filled.
+  byte* End() const {
+    return end_;
+  }
+
  protected:
-  explicit LargeObjectSpace(const std::string& name);
+  explicit LargeObjectSpace(const std::string& name, byte* begin, byte* end);
+
+  static void SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg);
 
   // Approximate number of bytes which have been allocated into the space.
-  size_t num_bytes_allocated_;
-  size_t num_objects_allocated_;
-  size_t total_bytes_allocated_;
-  size_t total_objects_allocated_;
+  uint64_t num_bytes_allocated_;
+  uint64_t num_objects_allocated_;
+  uint64_t total_bytes_allocated_;
+  uint64_t total_objects_allocated_;
+
+  // Begin and end, may change as more large objects are allocated.
+  byte* begin_;
+  byte* end_;
 
   friend class Space;
 
@@ -242,9 +258,6 @@
   typedef std::set<AllocationHeader*, AllocationHeader::SortByPrevFree,
                    accounting::GcAllocator<AllocationHeader*> > FreeBlocks;
 
-  byte* const begin_;
-  byte* const end_;
-
   // There is not footer for any allocations at the end of the space, so we keep track of how much
   // free space there is at the end manually.
   UniquePtr<MemMap> mem_map_;