1// Copyright 2006-2008 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include <stdlib.h>
29
30#include "v8.h"
31
32#include "global-handles.h"
33#include "snapshot.h"
34#include "cctest.h"
35
36using namespace v8::internal;
37
38static v8::Persistent<v8::Context> env;
39
40static void InitializeVM() {
41  if (env.IsEmpty()) env = v8::Context::New();
42  v8::HandleScope scope;
43  env->Enter();
44}
45
46
47TEST(MarkingStack) {
48  int mem_size = 20 * kPointerSize;
49  byte* mem = NewArray<byte>(20*kPointerSize);
50  Address low = reinterpret_cast<Address>(mem);
51  Address high = low + mem_size;
52  MarkingStack s;
53  s.Initialize(low, high);
54
55  Address address = NULL;
56  while (!s.is_full()) {
57    s.Push(HeapObject::FromAddress(address));
58    address += kPointerSize;
59  }
60
61  while (!s.is_empty()) {
62    Address value = s.Pop()->address();
63    address -= kPointerSize;
64    CHECK_EQ(address, value);
65  }
66
67  CHECK_EQ(NULL, address);
68  DeleteArray(mem);
69}
70
71
72TEST(Promotion) {
73  // This test requires compaction. If compaction is turned off, we
74  // skip the entire test.
75  if (FLAG_never_compact) return;
76
77  // Ensure that we get a compacting collection so that objects are promoted
78  // from new space.
79  FLAG_gc_global = true;
80  FLAG_always_compact = true;
81  HEAP->ConfigureHeap(2*256*KB, 4*MB, 4*MB);
82
83  InitializeVM();
84
85  v8::HandleScope sc;
86
87  // Allocate a fixed array in the new space.
88  int array_size =
89      (HEAP->MaxObjectSizeInPagedSpace() - FixedArray::kHeaderSize) /
90      (kPointerSize * 4);
91  Object* obj = HEAP->AllocateFixedArray(array_size)->ToObjectChecked();
92
93  Handle<FixedArray> array(FixedArray::cast(obj));
94
95  // Array should be in the new space.
96  CHECK(HEAP->InSpace(*array, NEW_SPACE));
97
98  // Call the m-c collector, so array becomes an old object.
99  HEAP->CollectGarbage(OLD_POINTER_SPACE);
100
101  // Array now sits in the old space
102  CHECK(HEAP->InSpace(*array, OLD_POINTER_SPACE));
103}
104
105
106TEST(NoPromotion) {
107  HEAP->ConfigureHeap(2*256*KB, 4*MB, 4*MB);
108
109  // Test the situation that some objects in new space are promoted to
110  // the old space
111  InitializeVM();
112
113  v8::HandleScope sc;
114
115  // Do a mark compact GC to shrink the heap.
116  HEAP->CollectGarbage(OLD_POINTER_SPACE);
117
118  // Allocate a big Fixed array in the new space.
119  int size = (HEAP->MaxObjectSizeInPagedSpace() - FixedArray::kHeaderSize) /
120      kPointerSize;
121  Object* obj = HEAP->AllocateFixedArray(size)->ToObjectChecked();
122
123  Handle<FixedArray> array(FixedArray::cast(obj));
124
125  // Array still stays in the new space.
126  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  InitializeVM();
303  GlobalHandles* global_handles = Isolate::Current()->global_handles();
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(
353        Handle<HeapObject>::cast(g1s1).location(), g1_children, 1);
354    global_handles->AddObjectGroup(g2_objects, 2, NULL);
355    global_handles->AddImplicitReferences(
356        Handle<HeapObject>::cast(g2s2).location(), 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(
381        Handle<HeapObject>::cast(g1s1).location(), g1_children, 1);
382    global_handles->AddObjectGroup(g2_objects, 2, NULL);
383    global_handles->AddImplicitReferences(
384        Handle<HeapObject>::cast(g2s2).location(), 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
404
405class TestRetainedObjectInfo : public v8::RetainedObjectInfo {
406 public:
407  TestRetainedObjectInfo() : has_been_disposed_(false) {}
408
409  bool has_been_disposed() { return has_been_disposed_; }
410
411  virtual void Dispose() {
412    ASSERT(!has_been_disposed_);
413    has_been_disposed_ = true;
414  }
415
416  virtual bool IsEquivalent(v8::RetainedObjectInfo* other) {
417    return other == this;
418  }
419
420  virtual intptr_t GetHash() { return 0; }
421
422  virtual const char* GetLabel() { return "whatever"; }
423
424 private:
425  bool has_been_disposed_;
426};
427
428
429TEST(EmptyObjectGroups) {
430  InitializeVM();
431  GlobalHandles* global_handles = Isolate::Current()->global_handles();
432
433  v8::HandleScope handle_scope;
434
435  Handle<Object> object =
436      global_handles->Create(HEAP->AllocateFixedArray(1)->ToObjectChecked());
437
438  TestRetainedObjectInfo info;
439  global_handles->AddObjectGroup(NULL, 0, &info);
440  ASSERT(info.has_been_disposed());
441
442  global_handles->AddImplicitReferences(
443        Handle<HeapObject>::cast(object).location(), NULL, 0);
444}
445