int MarkCompactCollector::SweepInParallel(PagedSpace* space,
- intptr_t required_freed_bytes) {
+ int required_freed_bytes) {
PageIterator it(space);
FreeList* free_list = space == heap()->old_pointer_space()
? free_list_old_pointer_space_.get()
: free_list_old_data_space_.get();
FreeList private_free_list(space);
- intptr_t max_freed = 0;
- intptr_t max_freed_overall = 0;
+ int max_freed = 0;
+ int max_freed_overall = 0;
while (it.has_next()) {
Page* p = it.next();
if (p->TryParallelSweeping()) {
- max_freed = SweepConservatively<SWEEP_IN_PARALLEL>(
- space, &private_free_list, p);
+ max_freed = static_cast<int>(SweepConservatively<SWEEP_IN_PARALLEL>(
+ space, &private_free_list, p));
+ ASSERT(max_freed >= 0);
free_list->Concatenate(&private_free_list);
if (required_freed_bytes > 0 && max_freed >= required_freed_bytes) {
return max_freed;
// to a value larger than 0, then sweeping returns after a block of at least
// required_freed_bytes was freed. If required_freed_bytes was set to zero
// then the whole given space is swept.
- int SweepInParallel(PagedSpace* space, intptr_t required_freed_bytes);
+ int SweepInParallel(PagedSpace* space, int required_freed_bytes);
void WaitUntilSweepingCompleted();
}
-HeapObject* PagedSpace::EnsureSweepingProgress(int size_in_bytes) {
- ASSERT(size_in_bytes >= 0);
+HeapObject* PagedSpace::EnsureSweepingProgress(
+ int size_in_bytes) {
MarkCompactCollector* collector = heap()->mark_compact_collector();
if (collector->IsConcurrentSweepingInProgress(this)) {
// If sweeping is still in progress try to sweep pages on the main thread.
- intptr_t free_chunk =
+ int free_chunk =
collector->SweepInParallel(this, size_in_bytes);
- if (free_chunk >= static_cast<intptr_t>(size_in_bytes)) {
+ if (free_chunk >= size_in_bytes) {
HeapObject* object = free_list_.Allocate(size_in_bytes);
// We should be able to allocate an object here since we just freed that
// much memory.