src/heap.h

// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)

#ifndef ART_SRC_HEAP_H_
#define ART_SRC_HEAP_H_

#include <vector>

#include "globals.h"
#include "object.h"
#include "object_bitmap.h"
#include "thread.h"

namespace art {

class Space;
class HeapBitmap;

class Heap {
 public:
  static const size_t kStartupSize = 1 * MB;

  static const size_t kMaximumSize = 16 * MB;

  static bool Init() {
    return Init(kStartupSize, kMaximumSize);
  }

  static bool Init(size_t staring_size, size_t maximum_size);

  static void Destroy();

  // Allocates and initializes storage for a class instance.
  static Object* AllocObject(Class* klass);

  static Object* AllocObject(Class* klass, size_t num_bytes);

  static Array* AllocArray(Class* array_class,
                           size_t component_count,
                           size_t component_size) {
    size_t size = sizeof(Array) + component_count * component_size;
    Array* array = down_cast<Array*>(AllocObject(array_class, size));
    if (array != NULL) {
      array->SetLength(component_count);
    }
    return array;
  }

  static ObjectArray* AllocObjectArray(Class* object_array_class,
                                       size_t length) {
    return down_cast<ObjectArray*>(AllocArray(object_array_class,
                                              length,
                                              sizeof(uint32_t)));
  }

  static CharArray* AllocCharArray(Class* char_array_class, size_t length) {
    return down_cast<CharArray*>(AllocArray(char_array_class,
                                            length,
                                            sizeof(uint16_t)));
  }

  static String* AllocString(Class* java_lang_String) {
    return down_cast<String*>(AllocObject(java_lang_String));
  }

  static String* AllocStringFromModifiedUtf8(Class* java_lang_String,
                                             Class* char_array,
                                             const char* data);

  // Initiates an explicit garbage collection.
  static void CollectGarbage();

  // Blocks the caller until the garbage collector becomes idle.
  static void WaitForConcurrentGcToComplete();

  static Mutex* GetLock() {
    return lock_;
  }

  static const std::vector<Space*>& GetSpaces() {
    return spaces_;
  }

  static HeapBitmap* GetLiveBits() {
    return live_bitmap_;
  };

  static HeapBitmap* GetMarkBits() {
    return mark_bitmap_;
  };

  static size_t GetMaximumSize() {
    return maximum_size_;
  }

 private:
  // Allocates uninitialized storage.
  static Object* Allocate(size_t num_bytes);
  static Object* Allocate(Space* space, size_t num_bytes);

  static void RecordAllocation(Space* space, const Object* object);
  static void RecordFree(Space* space, const Object* object);

  static void CollectGarbageInternal();

  static void GrowForUtilization();

  static Mutex* lock_;

  static std::vector<Space*> spaces_;

  static HeapBitmap* mark_bitmap_;

  static HeapBitmap* live_bitmap_;

  // The startup size of the heap in bytes.
  static size_t startup_size_;

  // The maximum size of the heap in bytes.
  static size_t maximum_size_;

  // True while the garbage collector is running.
  static bool is_gc_running_;

  // Number of bytes allocated.  Adjusted after each allocation and
  // free.
  static size_t num_bytes_allocated_;

  // Number of objects allocated.  Adjusted after each allocation and
  // free.
  static size_t num_objects_allocated_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(Heap);
};

class HeapLock {
 public:
  HeapLock(Heap* heap) : lock_(heap->GetLock()) {
    lock_->Lock();
  }
  ~HeapLock() {
    lock_->Unlock();
  }
 private:
  Mutex* lock_;
  DISALLOW_COPY_AND_ASSIGN(HeapLock);
};

}  // namespace art

#endif  // ART_SRC_HEAP_H_