AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Two tiny refactorings: Removed a bit of copy-n-paste. Moved LargeObjectChunk::Free from header to implementation, it does a syscall, anyway.

Browse Source 
Review URL: http://codereview.chromium.org/7744023

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@9017 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
svenpanne@chromium.org 2011-08-25 13:35:15 +00:00
parent 893b8320b8
commit 3d88d16f47
3 changed files with 16 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/spaces-inl.h
View File

@ -433,23 +433,6 @@ MaybeObject* PagedSpace::MCAllocateRaw(int size_in_bytes) {
} }
// -----------------------------------------------------------------------------
// LargeObjectChunk
Address LargeObjectChunk::GetStartAddress() {
// Round the chunk address up to the nearest page-aligned address
// and return the heap object in that page.
Page* page = Page::FromAddress(RoundUp(address(), Page::kPageSize));
return page->ObjectAreaStart();
}
void LargeObjectChunk::Free(Executability executable) {
Isolate* isolate =
Page::FromAddress(RoundUp(address(), Page::kPageSize))->heap_->isolate();
isolate->memory_allocator()->FreeRawMemory(address(), size(), executable);
}
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// NewSpace // NewSpace

18
src/spaces.cc
View File

@ -2722,12 +2722,17 @@ LargeObjectChunk* LargeObjectChunk::New(int size_in_bytes,
LargeObjectChunk* chunk = reinterpret_cast<LargeObjectChunk*>(mem); LargeObjectChunk* chunk = reinterpret_cast<LargeObjectChunk*>(mem);
chunk->size_ = size; chunk->size_ = size;
Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize)); chunk->GetPage()->heap_ = isolate->heap();
page->heap_ = isolate->heap();
return chunk; return chunk;
} }
void LargeObjectChunk::Free(Executability executable) {
Isolate* isolate = GetPage()->heap_->isolate();
isolate->memory_allocator()->FreeRawMemory(address(), size(), executable);
}
int LargeObjectChunk::ChunkSizeFor(int size_in_bytes) { int LargeObjectChunk::ChunkSizeFor(int size_in_bytes) {
int os_alignment = static_cast<int>(OS::AllocateAlignment()); int os_alignment = static_cast<int>(OS::AllocateAlignment());
if (os_alignment < Page::kPageSize) { if (os_alignment < Page::kPageSize) {
@ -2761,8 +2766,7 @@ void LargeObjectSpace::TearDown() {
LargeObjectChunk* chunk = first_chunk_; LargeObjectChunk* chunk = first_chunk_;
first_chunk_ = first_chunk_->next(); first_chunk_ = first_chunk_->next();
LOG(heap()->isolate(), DeleteEvent("LargeObjectChunk", chunk->address())); LOG(heap()->isolate(), DeleteEvent("LargeObjectChunk", chunk->address()));
Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize)); Executability executable = chunk->GetPage()->PageExecutability();
Executability executable = page->PageExecutability();
ObjectSpace space = kObjectSpaceLoSpace; ObjectSpace space = kObjectSpaceLoSpace;
if (executable == EXECUTABLE) space = kObjectSpaceCodeSpace; if (executable == EXECUTABLE) space = kObjectSpaceCodeSpace;
size_t size = chunk->size(); size_t size = chunk->size();
@ -2805,7 +2809,7 @@ MaybeObject* LargeObjectSpace::AllocateRawInternal(int requested_size,
first_chunk_ = chunk; first_chunk_ = chunk;
// Initialize page header. // Initialize page header.
Page* page = Page::FromAddress(RoundUp(chunk->address(), Page::kPageSize)); Page* page = chunk->GetPage();
Address object_address = page->ObjectAreaStart(); Address object_address = page->ObjectAreaStart();
// Clear the low order bit of the second word in the page to flag it as a // Clear the low order bit of the second word in the page to flag it as a
@ -2943,9 +2947,7 @@ void LargeObjectSpace::FreeUnmarkedObjects() {
previous = current; previous = current;
current = current->next(); current = current->next();
} else { } else {
Page* page = Page::FromAddress(RoundUp(current->address(), Executability executable = current->GetPage()->PageExecutability();
Page::kPageSize));
Executability executable = page->PageExecutability();
Address chunk_address = current->address(); Address chunk_address = current->address();
size_t chunk_size = current->size(); size_t chunk_size = current->size();

8
src/spaces.h
View File

@ -2144,7 +2144,7 @@ class LargeObjectChunk {
static LargeObjectChunk* New(int size_in_bytes, Executability executable); static LargeObjectChunk* New(int size_in_bytes, Executability executable);
// Free the memory associated with the chunk. // Free the memory associated with the chunk.
inline void Free(Executability executable); void Free(Executability executable);
// Interpret a raw address as a large object chunk. // Interpret a raw address as a large object chunk.
static LargeObjectChunk* FromAddress(Address address) { static LargeObjectChunk* FromAddress(Address address) {
@ -2154,13 +2154,17 @@ class LargeObjectChunk {
// Returns the address of this chunk. // Returns the address of this chunk.
Address address() { return reinterpret_cast<Address>(this); } Address address() { return reinterpret_cast<Address>(this); }
Page* GetPage() {
return Page::FromAddress(RoundUp(address(), Page::kPageSize));
}
// Accessors for the fields of the chunk. // Accessors for the fields of the chunk.
LargeObjectChunk* next() { return next_; } LargeObjectChunk* next() { return next_; }
void set_next(LargeObjectChunk* chunk) { next_ = chunk; } void set_next(LargeObjectChunk* chunk) { next_ = chunk; }
size_t size() { return size_ & ~Page::kPageFlagMask; } size_t size() { return size_ & ~Page::kPageFlagMask; }
// Compute the start address in the chunk. // Compute the start address in the chunk.
inline Address GetStartAddress(); Address GetStartAddress() { return GetPage()->ObjectAreaStart(); }
// Returns the object in this chunk. // Returns the object in this chunk.
HeapObject* GetObject() { return HeapObject::FromAddress(GetStartAddress()); } HeapObject* GetObject() { return HeapObject::FromAddress(GetStartAddress()); }