[heap] inline allocation steps refactor

test/cctest/test-spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 627 matching lines @@
 
       // Turn the allocation into a proper object so isolate teardown won't
       // crash.
       HeapObject* free_space = NULL;
       CHECK(allocation.To(&free_space));
       new_space->heap()->CreateFillerObjectAt(free_space->address(), 80);
     }
   }
   isolate->Dispose();
 }
+
+
+static HeapObject* AllocateUnaligned(NewSpace* space, int size) {
+  AllocationResult allocation = space->AllocateRawUnaligned(size);
+  CHECK(!allocation.IsRetry());
+  HeapObject* filler = NULL;
+  CHECK(allocation.To(&filler));
+  space->heap()->CreateFillerObjectAt(filler->address(), size);
+  return filler;
+}
+
+
+static void observer1(int bytes_allocated, void* arg) {
+  int* counter = static_cast<int*>(arg);
+  (*counter)++;
+}
+
+
+static void observer2(int bytes_allocated, void* arg) {
+  int* counter = static_cast<int*>(arg);
+  (*counter)++;
+}
+
+
+UNINITIALIZED_TEST(InlineAllocationObserver) {
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
+  {
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+    v8::Context::New(isolate)->Enter();
+
+    Isolate* i_isolate = reinterpret_cast<Isolate*>(isolate);
+
+    NewSpace* new_space = i_isolate->heap()->new_space();
+
+    int counter1 = 0;
+    new_space->AddInlineAllocationObserver(128, observer1, &counter1);
+
+    // The observer should not get notified until we have allocated a 128 bytes.
+    AllocateUnaligned(new_space, 64);
+    CHECK_EQ(counter1, 0);
+
+    // The observer should get notified when have allocated precisely 128 bytes.
+    AllocateUnaligned(new_space, 64);
+    CHECK_EQ(counter1, 1);
+
+    // Another 128 bytes should get another notification.
+    AllocateUnaligned(new_space, 128);
+    CHECK_EQ(counter1, 2);
+
+    // Allocating a large object should get only one notification.
+    AllocateUnaligned(new_space, 1024);
+    CHECK_EQ(counter1, 3);
+
+    // Allocating another 2048 bytes in small objects should get 16
+    // notifications.
+    for (int i = 0; i < 64; ++i) {
+      AllocateUnaligned(new_space, 32);
+    }
+    CHECK_EQ(counter1, 19);
+
+    // Multiple observers should work.
+    int counter2 = 0;
+    new_space->AddInlineAllocationObserver(96, observer2, &counter2);
+
+    AllocateUnaligned(new_space, 2048);
+    CHECK_EQ(counter1, 20);
+    CHECK_EQ(counter2, 1);
+
+    AllocateUnaligned(new_space, 96);
+    CHECK_EQ(counter1, 20);
+    CHECK_EQ(counter2, 2);
+
+    // Callback should stop getting called after an observer is removed.
+    new_space->RemoveInlineAllocationObserver(observer1);
+
+    AllocateUnaligned(new_space, 384);
+    CHECK_EQ(counter1, 20);  // no more notifications.
+    CHECK_EQ(counter2, 3);   // this one is still active.
+
+    // The same function pointer can be added multiple times.
+    int counter3 = 0;
+    new_space->AddInlineAllocationObserver(32, observer2, &counter3);
+
+    // Both counter2, and counter3 should be getting updated now.
+    AllocateUnaligned(new_space, 128);
+    CHECK_EQ(counter1, 20);
+    CHECK_EQ(counter2, 4);
+    CHECK_EQ(counter3, 1);
+
+    // Removing an duplicated observer removes it in the order of addition.
+    new_space->RemoveInlineAllocationObserver(observer2);
+    AllocateUnaligned(new_space, 128);
+    CHECK_EQ(counter1, 20);
+    CHECK_EQ(counter2, 4);
+    CHECK_EQ(counter3, 2);  // this one should still get updated.
+
+    // Should be able to remove the second instance of observer2.
+    new_space->RemoveInlineAllocationObserver(observer2);
+    CHECK_EQ(counter1, 20);
+    CHECK_EQ(counter2, 4);
+    CHECK_EQ(counter3, 2);
+  }
+  isolate->Dispose();
+}