CSE2410 Fall 2014 Bounce

#include "macro-assembler.h"

#include "mark-compact.h"

#include "platform.h"

namespace v8 {

                                                executable,

                                                owner);

  result->set_reserved_memory(&reservation);

  return result;

}

      * AreaSize();

  accounting_stats_.Clear();

  anchor_.InitializeAsAnchor(this);

}

size_t PagedSpace::CommittedPhysicalMemory() {

  if (!VirtualMemory::HasLazyCommits()) return CommittedMemory();

  size_t size = 0;

  PageIterator it(this);

  while (it.has_next()) {

  int size = 0;

  switch (identity()) {

    case OLD_POINTER_SPACE:

      break;

    case OLD_DATA_SPACE:

      size = 192 * KB;

        // upgraded to handle small pages.

        size = AreaSize();

      } else {

      }

      break;

    default:

    DecreaseUnsweptFreeBytes(page);

  }

  }

  if (unlink) {

  if (was_swept_conservatively_) return;

  bool allocation_pointer_found_in_space =

  PageIterator page_iterator(this);

  while (page_iterator.has_next()) {

    Page* page = page_iterator.next();

    CHECK(page->owner() == this);

      allocation_pointer_found_in_space = true;

    }

    CHECK(page->WasSweptPrecisely());

  }

  start_ = NULL;

  to_space_.TearDown();

  from_space_.TearDown();

      }

    }

  }

  ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);

}

void NewSpace::UpdateAllocationInfo() {

  // Lower limit during incremental marking.

  if (heap()->incremental_marking()->IsMarking() &&

      inline_allocation_limit_step() != 0) {

    Address new_limit =

  }

  ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);

}

bool NewSpace::AddFreshPage() {

  if (NewSpacePage::IsAtStart(top)) {

    // The current page is already empty. Don't try to make another.

MaybeObject* NewSpace::SlowAllocateRaw(int size_in_bytes) {

  Address new_top = old_top + size_in_bytes;

  Address high = to_space_.page_high();

    // Incremental marking has lowered the limit to get a

    // chance to do a step.

        high);

    int bytes_allocated = static_cast<int>(new_top - top_on_previous_step_);

    heap()->incremental_marking()->Step(

        bytes_allocated, IncrementalMarking::GC_VIA_STACK_GUARD);

bool SemiSpace::Commit() {

  ASSERT(!is_committed());

  int pages = capacity_ / Page::kPageSize;

                                                          capacity_,

                                                          executable())) {

    return false;

  }

    NewSpacePage* new_page =

  }

  committed_ = true;

  int pages_before = capacity_ / Page::kPageSize;

  int pages_after = new_capacity / Page::kPageSize;

  size_t delta = new_capacity - capacity_;

  ASSERT(IsAligned(delta, OS::AllocateAlignment()));

  if (!heap()->isolate()->memory_allocator()->CommitBlock(

    return false;

  }

  capacity_ = new_capacity;

  NewSpacePage* last_page = anchor()->prev_page();

  ASSERT(last_page != anchor());

    NewSpacePage* new_page = NewSpacePage::Initialize(heap(),

                                                      page_address,

                                                      this);

  ASSERT(new_capacity >= initial_capacity_);

  ASSERT(new_capacity < capacity_);

  if (is_committed()) {

    size_t delta = capacity_ - new_capacity;

    ASSERT(IsAligned(delta, OS::AllocateAlignment()));

    MemoryAllocator* allocator = heap()->isolate()->memory_allocator();

      return false;

    }

    int pages_after = new_capacity / Page::kPageSize;

    NewSpacePage* new_last_page =

    new_last_page->set_next_page(anchor());

    anchor()->set_prev_page(new_last_page);

  }

  capacity_ = new_capacity;

size_t NewSpace::CommittedPhysicalMemory() {

  if (!VirtualMemory::HasLazyCommits()) return CommittedMemory();

  size_t size = to_space_.CommittedPhysicalMemory();

  if (from_space_.is_committed()) {

    size += from_space_.CommittedPhysicalMemory();

  Object* object = NULL;

  if (!maybe->ToObject(&object)) return false;

  HeapObject* allocation = HeapObject::cast(object);

  if ((top - bytes) == allocation->address()) {

    return true;

  }

  // There may be a borderline case here where the allocation succeeded, but

bool PagedSpace::ReserveSpace(int size_in_bytes) {

  ASSERT(size_in_bytes <= AreaSize());

  ASSERT(size_in_bytes == RoundSizeDownToObjectAlignment(size_in_bytes));

  Address new_top = current_top + size_in_bytes;

  HeapObject* new_area = free_list_.Allocate(size_in_bytes);

  if (new_area == NULL) new_area = SlowAllocateRaw(size_in_bytes);

void PagedSpace::EvictEvacuationCandidatesFromFreeLists() {

    // Create filler object to keep page iterable if it was iterable.

    int remaining =

  }

}

  // Try to expand the space and allocate in the new next page.

  if (Expand()) {

    return free_list_.Allocate(size_in_bytes);

  }