Add ImmutableHeap class consisting of parts

src/vm/immutable_heap.h

Index: src/vm/immutable_heap.h
diff --git a/src/vm/immutable_heap.h b/src/vm/immutable_heap.h
new file mode 100644
index 0000000000000000000000000000000000000000..d4340940372d89e7e2a1186a3fb04359b777c0a9
--- /dev/null
+++ b/src/vm/immutable_heap.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2015, the Fletch project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE.md file.
+
+#ifndef SRC_VM_IMMUTABLE_HEAP_H_
+#define SRC_VM_IMMUTABLE_HEAP_H_
+
+#include "src/shared/globals.h"
+#include "src/vm/heap.h"
+
+namespace fletch {
+
+class ImmutableHeap {
+ public:
+  ImmutableHeap();
+  ~ImmutableHeap();
+
+  // Will return a [Heap] which will have an allocation budget which is
+  // ``.

[Mads Ager (google), 2015/08/05 10:19:02]

Finish comment please.

[kustermann, 2015/08/05 11:11:46]

Done.

+  Heap* AcquirePart();
+  // Will return `true` if the caller should trigger an immutable GC.

[Mads Ager (google), 2015/08/05 10:19:02]

Newline before comment?

[kustermann, 2015/08/05 11:11:46]

Done.

+  //
+  // It is assumed that this function gets only called on allocation failures.

[Mads Ager (google), 2015/08/05 10:19:02]

gets only called -> is called only 

[kustermann, 2015/08/05 11:11:46]

Done.

+  bool ReleasePart(Heap* part);
+  void MergeParts();

[Mads Ager (google), 2015/08/05 10:19:03]

Document this one as well?

[kustermann, 2015/08/05 11:11:46]

Done.

+
+  // This method can only be called if
+  //   * all acquired parts were released again
+  //   * all cached parts were merged via [MergeParts]
+  void IterateProgramPointers(PointerVisitor* visitor);
+
+  // This method can only be called if
+  //   * all acquired parts were released again
+  //   * all cached parts were merged via [MergeParts]
+  Heap* heap() {
+    ASSERT(outstanding_parts_ == 0 && cached_parts_ == NULL);
+    return &heap_;
+  }
+
+ private:
+  // TODO(kustermann): Instead of having a linked list which requires heap
+  // allocations we should make a simple version of `std::vector` and use it
+  // here.
+  // [The number of parts is almost always fixed (i.e. the number of threads)]
+  struct CachedHeapPart {

[Mads Ager (google), 2015/08/05 10:19:02]

Let's just use a class instead of a struct. It is the same modulo visibility.

Why not take heap_part and next in the constructor?

[kustermann, 2015/08/05 11:11:46]

"Let's just use a class instead of a struct. It is the same modulo visibility."

Done. Now all fields are public and I removed the underscore.

"Why not take heap_part and next in the constructor?"

I've decided that the destructor will not delete the heap. Which means the
object doesn't own the heap. Other code (e.g. Heap, Space) delete what they get
in the constructor, to not make one assume we do the same here, the constructor
doesn't take the heap (or next).

+    CachedHeapPart() : heap_part_(NULL), next_(NULL) {}
+    Heap* heap_part_;
+    struct CachedHeapPart* next_;
+  };
+
+ private:

[Mads Ager (google), 2015/08/05 10:19:03]

Remove extra 'private:'

[kustermann, 2015/08/05 11:11:46]

Done.

+  bool HasCachedParts() { return cached_parts_ != NULL; }
+  void AddCachedPart(Heap* heap);
+  Heap* RemoveCachedPart();
+
+  int number_of_hw_threads_;
+
+  Mutex* heap_mutex_;
+  Heap heap_;
+  int outstanding_parts_;
+  CachedHeapPart* cached_parts_;

[Mads Ager (google), 2015/08/05 10:19:02]

I guess these are the parts that are no longer outstanding because they have
been returned. Maybe call it returned_parts_ or unmerged_parts_? Maybe call
ticks_ number_of_returned_parts_ or number_of_unmerged_parts_?

[kustermann, 2015/08/05 11:11:46]

Done.

Picked "number_of_unmerged_parts_" and removed/renamed "Cached"  in other
methods and the struct.

+  int ticks_;
+};
+
+}  // namespace fletch
+
+
+#endif  // SRC_VM_IMMUTABLE_HEAP_H_