test-mark-compact.cc revision 44f0eee88ff00398ff7f715fab053374d808c90d
159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// Copyright 2006-2008 the V8 project authors. All rights reserved. 259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// Redistribution and use in source and binary forms, with or without 359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// modification, are permitted provided that the following conditions are 459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// met: 559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// 659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// * Redistributions of source code must retain the above copyright 759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// notice, this list of conditions and the following disclaimer. 859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// * Redistributions in binary form must reproduce the above 959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// copyright notice, this list of conditions and the following 1059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// disclaimer in the documentation and/or other materials provided 1159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// with the distribution. 1259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// * Neither the name of Google Inc. nor the names of its 1359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// contributors may be used to endorse or promote products derived 1459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// from this software without specific prior written permission. 1559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// 1659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 1859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 1959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 2859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta#include <stdlib.h> 2959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 3059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta#include "v8.h" 3159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 3259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta#include "global-handles.h" 3359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta#include "snapshot.h" 3459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta#include "cctest.h" 3559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 3659b2e6871c65f58fdad78cd7229c292f6a177578Scott Bartausing namespace v8::internal; 3759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 3859b2e6871c65f58fdad78cd7229c292f6a177578Scott Bartastatic v8::Persistent<v8::Context> env; 3959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 4059b2e6871c65f58fdad78cd7229c292f6a177578Scott Bartastatic void InitializeVM() { 4159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta if (env.IsEmpty()) env = v8::Context::New(); 4259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta v8::HandleScope scope; 4359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta env->Enter(); 4459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta} 4559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 4659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 4759b2e6871c65f58fdad78cd7229c292f6a177578Scott BartaTEST(MarkingStack) { 4859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta int mem_size = 20 * kPointerSize; 4959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta byte* mem = NewArray<byte>(20*kPointerSize); 5059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Address low = reinterpret_cast<Address>(mem); 5159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Address high = low + mem_size; 5259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta MarkingStack s; 5359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta s.Initialize(low, high); 5459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 5559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Address address = NULL; 5659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta while (!s.is_full()) { 5759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta s.Push(HeapObject::FromAddress(address)); 5859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta address += kPointerSize; 5959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta } 6059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 6159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta while (!s.is_empty()) { 6259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Address value = s.Pop()->address(); 6359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta address -= kPointerSize; 6459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta CHECK_EQ(address, value); 6559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta } 6659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 6759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta CHECK_EQ(NULL, address); 6859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta DeleteArray(mem); 6959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta} 7059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 7159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 7259b2e6871c65f58fdad78cd7229c292f6a177578Scott BartaTEST(Promotion) { 7359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // This test requires compaction. If compaction is turned off, we 7459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // skip the entire test. 7559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta if (FLAG_never_compact) return; 7659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 7759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Ensure that we get a compacting collection so that objects are promoted 7859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // from new space. 7959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta FLAG_gc_global = true; 8059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta FLAG_always_compact = true; 8159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta HEAP->ConfigureHeap(2*256*KB, 4*MB, 4*MB); 8259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 8359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta InitializeVM(); 8459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 8559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta v8::HandleScope sc; 8659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 8759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Allocate a fixed array in the new space. 8859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta int array_size = 8959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta (HEAP->MaxObjectSizeInPagedSpace() - FixedArray::kHeaderSize) / 9059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta (kPointerSize * 4); 9159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Object* obj = HEAP->AllocateFixedArray(array_size)->ToObjectChecked(); 9259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 9359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Handle<FixedArray> array(FixedArray::cast(obj)); 9459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 9559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Array should be in the new space. 9659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta CHECK(HEAP->InSpace(*array, NEW_SPACE)); 9759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 9859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Call the m-c collector, so array becomes an old object. 9959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta HEAP->CollectGarbage(OLD_POINTER_SPACE); 10059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 10159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Array now sits in the old space 10259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta CHECK(HEAP->InSpace(*array, OLD_POINTER_SPACE)); 10359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta} 10459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 10559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 10659b2e6871c65f58fdad78cd7229c292f6a177578Scott BartaTEST(NoPromotion) { 10759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta HEAP->ConfigureHeap(2*256*KB, 4*MB, 4*MB); 10859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 10959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Test the situation that some objects in new space are promoted to 11059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // the old space 11159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta InitializeVM(); 11259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 11359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta v8::HandleScope sc; 11459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 11559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Do a mark compact GC to shrink the heap. 11659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta HEAP->CollectGarbage(OLD_POINTER_SPACE); 11759b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 11859b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Allocate a big Fixed array in the new space. 11959b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta int size = (HEAP->MaxObjectSizeInPagedSpace() - FixedArray::kHeaderSize) / 12059b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta kPointerSize; 12159b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Object* obj = HEAP->AllocateFixedArray(size)->ToObjectChecked(); 12259b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 12359b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta Handle<FixedArray> array(FixedArray::cast(obj)); 12459b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta 12559b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta // Array still stays in the new space. 12659b2e6871c65f58fdad78cd7229c292f6a177578Scott Barta CHECK(HEAP->InSpace(*array, NEW_SPACE)); 127 128 // Allocate objects in the old space until out of memory. 129 FixedArray* host = *array; 130 while (true) { 131 Object* obj; 132 { MaybeObject* maybe_obj = HEAP->AllocateFixedArray(100, TENURED); 133 if (!maybe_obj->ToObject(&obj)) break; 134 } 135 136 host->set(0, obj); 137 host = FixedArray::cast(obj); 138 } 139 140 // Call mark compact GC, and it should pass. 141 HEAP->CollectGarbage(OLD_POINTER_SPACE); 142 143 // array should not be promoted because the old space is full. 144 CHECK(HEAP->InSpace(*array, NEW_SPACE)); 145} 146 147 148TEST(MarkCompactCollector) { 149 InitializeVM(); 150 151 v8::HandleScope sc; 152 // call mark-compact when heap is empty 153 HEAP->CollectGarbage(OLD_POINTER_SPACE); 154 155 // keep allocating garbage in new space until it fails 156 const int ARRAY_SIZE = 100; 157 Object* array; 158 MaybeObject* maybe_array; 159 do { 160 maybe_array = HEAP->AllocateFixedArray(ARRAY_SIZE); 161 } while (maybe_array->ToObject(&array)); 162 HEAP->CollectGarbage(NEW_SPACE); 163 164 array = HEAP->AllocateFixedArray(ARRAY_SIZE)->ToObjectChecked(); 165 166 // keep allocating maps until it fails 167 Object* mapp; 168 MaybeObject* maybe_mapp; 169 do { 170 maybe_mapp = HEAP->AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize); 171 } while (maybe_mapp->ToObject(&mapp)); 172 HEAP->CollectGarbage(MAP_SPACE); 173 mapp = HEAP->AllocateMap(JS_OBJECT_TYPE, 174 JSObject::kHeaderSize)->ToObjectChecked(); 175 176 // allocate a garbage 177 String* func_name = 178 String::cast(HEAP->LookupAsciiSymbol("theFunction")->ToObjectChecked()); 179 SharedFunctionInfo* function_share = SharedFunctionInfo::cast( 180 HEAP->AllocateSharedFunctionInfo(func_name)->ToObjectChecked()); 181 JSFunction* function = JSFunction::cast( 182 HEAP->AllocateFunction(*Isolate::Current()->function_map(), 183 function_share, 184 HEAP->undefined_value())->ToObjectChecked()); 185 Map* initial_map = 186 Map::cast(HEAP->AllocateMap(JS_OBJECT_TYPE, 187 JSObject::kHeaderSize)->ToObjectChecked()); 188 function->set_initial_map(initial_map); 189 Isolate::Current()->context()->global()->SetProperty( 190 func_name, function, NONE, kNonStrictMode)->ToObjectChecked(); 191 192 JSObject* obj = JSObject::cast( 193 HEAP->AllocateJSObject(function)->ToObjectChecked()); 194 HEAP->CollectGarbage(OLD_POINTER_SPACE); 195 196 func_name = 197 String::cast(HEAP->LookupAsciiSymbol("theFunction")->ToObjectChecked()); 198 CHECK(Isolate::Current()->context()->global()->HasLocalProperty(func_name)); 199 Object* func_value = Isolate::Current()->context()->global()-> 200 GetProperty(func_name)->ToObjectChecked(); 201 CHECK(func_value->IsJSFunction()); 202 function = JSFunction::cast(func_value); 203 204 obj = JSObject::cast(HEAP->AllocateJSObject(function)->ToObjectChecked()); 205 String* obj_name = 206 String::cast(HEAP->LookupAsciiSymbol("theObject")->ToObjectChecked()); 207 Isolate::Current()->context()->global()->SetProperty( 208 obj_name, obj, NONE, kNonStrictMode)->ToObjectChecked(); 209 String* prop_name = 210 String::cast(HEAP->LookupAsciiSymbol("theSlot")->ToObjectChecked()); 211 obj->SetProperty(prop_name, 212 Smi::FromInt(23), 213 NONE, 214 kNonStrictMode)->ToObjectChecked(); 215 216 HEAP->CollectGarbage(OLD_POINTER_SPACE); 217 218 obj_name = 219 String::cast(HEAP->LookupAsciiSymbol("theObject")->ToObjectChecked()); 220 CHECK(Isolate::Current()->context()->global()->HasLocalProperty(obj_name)); 221 CHECK(Isolate::Current()->context()->global()-> 222 GetProperty(obj_name)->ToObjectChecked()->IsJSObject()); 223 obj = JSObject::cast(Isolate::Current()->context()->global()-> 224 GetProperty(obj_name)->ToObjectChecked()); 225 prop_name = 226 String::cast(HEAP->LookupAsciiSymbol("theSlot")->ToObjectChecked()); 227 CHECK(obj->GetProperty(prop_name) == Smi::FromInt(23)); 228} 229 230 231static Handle<Map> CreateMap() { 232 return FACTORY->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize); 233} 234 235 236TEST(MapCompact) { 237 FLAG_max_map_space_pages = 16; 238 InitializeVM(); 239 240 { 241 v8::HandleScope sc; 242 // keep allocating maps while pointers are still encodable and thus 243 // mark compact is permitted. 244 Handle<JSObject> root = FACTORY->NewJSObjectFromMap(CreateMap()); 245 do { 246 Handle<Map> map = CreateMap(); 247 map->set_prototype(*root); 248 root = FACTORY->NewJSObjectFromMap(map); 249 } while (HEAP->map_space()->MapPointersEncodable()); 250 } 251 // Now, as we don't have any handles to just allocated maps, we should 252 // be able to trigger map compaction. 253 // To give an additional chance to fail, try to force compaction which 254 // should be impossible right now. 255 HEAP->CollectAllGarbage(true); 256 // And now map pointers should be encodable again. 257 CHECK(HEAP->map_space()->MapPointersEncodable()); 258} 259 260 261static int gc_starts = 0; 262static int gc_ends = 0; 263 264static void GCPrologueCallbackFunc() { 265 CHECK(gc_starts == gc_ends); 266 gc_starts++; 267} 268 269 270static void GCEpilogueCallbackFunc() { 271 CHECK(gc_starts == gc_ends + 1); 272 gc_ends++; 273} 274 275 276TEST(GCCallback) { 277 InitializeVM(); 278 279 HEAP->SetGlobalGCPrologueCallback(&GCPrologueCallbackFunc); 280 HEAP->SetGlobalGCEpilogueCallback(&GCEpilogueCallbackFunc); 281 282 // Scavenge does not call GC callback functions. 283 HEAP->PerformScavenge(); 284 285 CHECK_EQ(0, gc_starts); 286 CHECK_EQ(gc_ends, gc_starts); 287 288 HEAP->CollectGarbage(OLD_POINTER_SPACE); 289 CHECK_EQ(1, gc_starts); 290 CHECK_EQ(gc_ends, gc_starts); 291} 292 293 294static int NumberOfWeakCalls = 0; 295static void WeakPointerCallback(v8::Persistent<v8::Value> handle, void* id) { 296 ASSERT(id == reinterpret_cast<void*>(1234)); 297 NumberOfWeakCalls++; 298 handle.Dispose(); 299} 300 301TEST(ObjectGroups) { 302 GlobalHandles* global_handles = Isolate::Current()->global_handles(); 303 InitializeVM(); 304 305 NumberOfWeakCalls = 0; 306 v8::HandleScope handle_scope; 307 308 Handle<Object> g1s1 = 309 global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked()); 310 Handle<Object> g1s2 = 311 global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked()); 312 Handle<Object> g1c1 = 313 global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked()); 314 global_handles->MakeWeak(g1s1.location(), 315 reinterpret_cast<void*>(1234), 316 &WeakPointerCallback); 317 global_handles->MakeWeak(g1s2.location(), 318 reinterpret_cast<void*>(1234), 319 &WeakPointerCallback); 320 global_handles->MakeWeak(g1c1.location(), 321 reinterpret_cast<void*>(1234), 322 &WeakPointerCallback); 323 324 Handle<Object> g2s1 = 325 global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked()); 326 Handle<Object> g2s2 = 327 global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked()); 328 Handle<Object> g2c1 = 329 global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked()); 330 global_handles->MakeWeak(g2s1.location(), 331 reinterpret_cast<void*>(1234), 332 &WeakPointerCallback); 333 global_handles->MakeWeak(g2s2.location(), 334 reinterpret_cast<void*>(1234), 335 &WeakPointerCallback); 336 global_handles->MakeWeak(g2c1.location(), 337 reinterpret_cast<void*>(1234), 338 &WeakPointerCallback); 339 340 Handle<Object> root = global_handles->Create(*g1s1); // make a root. 341 342 // Connect group 1 and 2, make a cycle. 343 Handle<FixedArray>::cast(g1s2)->set(0, *g2s2); 344 Handle<FixedArray>::cast(g2s1)->set(0, *g1s1); 345 346 { 347 Object** g1_objects[] = { g1s1.location(), g1s2.location() }; 348 Object** g1_children[] = { g1c1.location() }; 349 Object** g2_objects[] = { g2s1.location(), g2s2.location() }; 350 Object** g2_children[] = { g2c1.location() }; 351 global_handles->AddObjectGroup(g1_objects, 2, NULL); 352 global_handles->AddImplicitReferences(HeapObject::cast(*g1s1), 353 g1_children, 1); 354 global_handles->AddObjectGroup(g2_objects, 2, NULL); 355 global_handles->AddImplicitReferences(HeapObject::cast(*g2s2), 356 g2_children, 1); 357 } 358 // Do a full GC 359 HEAP->CollectGarbage(OLD_POINTER_SPACE); 360 361 // All object should be alive. 362 CHECK_EQ(0, NumberOfWeakCalls); 363 364 // Weaken the root. 365 global_handles->MakeWeak(root.location(), 366 reinterpret_cast<void*>(1234), 367 &WeakPointerCallback); 368 // But make children strong roots---all the objects (except for children) 369 // should be collectable now. 370 global_handles->ClearWeakness(g1c1.location()); 371 global_handles->ClearWeakness(g2c1.location()); 372 373 // Groups are deleted, rebuild groups. 374 { 375 Object** g1_objects[] = { g1s1.location(), g1s2.location() }; 376 Object** g1_children[] = { g1c1.location() }; 377 Object** g2_objects[] = { g2s1.location(), g2s2.location() }; 378 Object** g2_children[] = { g2c1.location() }; 379 global_handles->AddObjectGroup(g1_objects, 2, NULL); 380 global_handles->AddImplicitReferences(HeapObject::cast(*g1s1), 381 g1_children, 1); 382 global_handles->AddObjectGroup(g2_objects, 2, NULL); 383 global_handles->AddImplicitReferences(HeapObject::cast(*g2s2), 384 g2_children, 1); 385 } 386 387 HEAP->CollectGarbage(OLD_POINTER_SPACE); 388 389 // All objects should be gone. 5 global handles in total. 390 CHECK_EQ(5, NumberOfWeakCalls); 391 392 // And now make children weak again and collect them. 393 global_handles->MakeWeak(g1c1.location(), 394 reinterpret_cast<void*>(1234), 395 &WeakPointerCallback); 396 global_handles->MakeWeak(g2c1.location(), 397 reinterpret_cast<void*>(1234), 398 &WeakPointerCallback); 399 400 HEAP->CollectGarbage(OLD_POINTER_SPACE); 401 CHECK_EQ(7, NumberOfWeakCalls); 402} 403