1// Copyright 2012 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 "src/v8.h" 29#include "test/cctest/cctest.h" 30 31#include "src/accessors.h" 32#include "src/api.h" 33 34 35using namespace v8::internal; 36 37 38static AllocationResult AllocateAfterFailures() { 39 static int attempts = 0; 40 41 if (++attempts < 3) return AllocationResult::Retry(); 42 TestHeap* heap = CcTest::test_heap(); 43 44 // New space. 45 SimulateFullSpace(heap->new_space()); 46 heap->AllocateByteArray(100).ToObjectChecked(); 47 heap->AllocateFixedArray(100, NOT_TENURED).ToObjectChecked(); 48 49 // Make sure we can allocate through optimized allocation functions 50 // for specific kinds. 51 heap->AllocateFixedArray(100).ToObjectChecked(); 52 heap->AllocateHeapNumber(0.42).ToObjectChecked(); 53 Object* object = heap->AllocateJSObject( 54 *CcTest::i_isolate()->object_function()).ToObjectChecked(); 55 heap->CopyJSObject(JSObject::cast(object)).ToObjectChecked(); 56 57 // Old data space. 58 SimulateFullSpace(heap->old_data_space()); 59 heap->AllocateByteArray(100, TENURED).ToObjectChecked(); 60 61 // Old pointer space. 62 SimulateFullSpace(heap->old_pointer_space()); 63 heap->AllocateFixedArray(10000, TENURED).ToObjectChecked(); 64 65 // Large object space. 66 static const int kLargeObjectSpaceFillerLength = 300000; 67 static const int kLargeObjectSpaceFillerSize = FixedArray::SizeFor( 68 kLargeObjectSpaceFillerLength); 69 DCHECK(kLargeObjectSpaceFillerSize > heap->old_pointer_space()->AreaSize()); 70 while (heap->OldGenerationSpaceAvailable() > kLargeObjectSpaceFillerSize) { 71 heap->AllocateFixedArray( 72 kLargeObjectSpaceFillerLength, TENURED).ToObjectChecked(); 73 } 74 heap->AllocateFixedArray( 75 kLargeObjectSpaceFillerLength, TENURED).ToObjectChecked(); 76 77 // Map space. 78 SimulateFullSpace(heap->map_space()); 79 int instance_size = JSObject::kHeaderSize; 80 heap->AllocateMap(JS_OBJECT_TYPE, instance_size).ToObjectChecked(); 81 82 // Test that we can allocate in old pointer space and code space. 83 SimulateFullSpace(heap->code_space()); 84 heap->AllocateFixedArray(100, TENURED).ToObjectChecked(); 85 heap->CopyCode(CcTest::i_isolate()->builtins()->builtin( 86 Builtins::kIllegal)).ToObjectChecked(); 87 88 // Return success. 89 return Smi::FromInt(42); 90} 91 92 93static Handle<Object> Test() { 94 CALL_HEAP_FUNCTION(CcTest::i_isolate(), AllocateAfterFailures(), Object); 95} 96 97 98TEST(StressHandles) { 99 v8::HandleScope scope(CcTest::isolate()); 100 v8::Handle<v8::Context> env = v8::Context::New(CcTest::isolate()); 101 env->Enter(); 102 Handle<Object> o = Test(); 103 CHECK(o->IsSmi() && Smi::cast(*o)->value() == 42); 104 env->Exit(); 105} 106 107 108void TestGetter( 109 v8::Local<v8::Name> name, 110 const v8::PropertyCallbackInfo<v8::Value>& info) { 111 i::Isolate* isolate = reinterpret_cast<i::Isolate*>(info.GetIsolate()); 112 HandleScope scope(isolate); 113 info.GetReturnValue().Set(v8::Utils::ToLocal(Test())); 114} 115 116 117void TestSetter( 118 v8::Local<v8::Name> name, 119 v8::Local<v8::Value> value, 120 const v8::PropertyCallbackInfo<void>& info) { 121 UNREACHABLE(); 122} 123 124 125Handle<AccessorInfo> TestAccessorInfo( 126 Isolate* isolate, PropertyAttributes attributes) { 127 Handle<String> name = isolate->factory()->NewStringFromStaticChars("get"); 128 return Accessors::MakeAccessor(isolate, name, &TestGetter, &TestSetter, 129 attributes); 130} 131 132 133TEST(StressJS) { 134 Isolate* isolate = CcTest::i_isolate(); 135 Factory* factory = isolate->factory(); 136 v8::HandleScope scope(CcTest::isolate()); 137 v8::Handle<v8::Context> env = v8::Context::New(CcTest::isolate()); 138 env->Enter(); 139 Handle<JSFunction> function = factory->NewFunction( 140 factory->function_string()); 141 // Force the creation of an initial map and set the code to 142 // something empty. 143 factory->NewJSObject(function); 144 function->ReplaceCode(CcTest::i_isolate()->builtins()->builtin( 145 Builtins::kEmptyFunction)); 146 // Patch the map to have an accessor for "get". 147 Handle<Map> map(function->initial_map()); 148 Handle<DescriptorArray> instance_descriptors(map->instance_descriptors()); 149 DCHECK(instance_descriptors->IsEmpty()); 150 151 PropertyAttributes attrs = static_cast<PropertyAttributes>(0); 152 Handle<AccessorInfo> foreign = TestAccessorInfo(isolate, attrs); 153 Map::EnsureDescriptorSlack(map, 1); 154 155 CallbacksDescriptor d(Handle<Name>(Name::cast(foreign->name())), 156 foreign, attrs); 157 map->AppendDescriptor(&d); 158 159 // Add the Foo constructor the global object. 160 env->Global()->Set(v8::String::NewFromUtf8(CcTest::isolate(), "Foo"), 161 v8::Utils::ToLocal(function)); 162 // Call the accessor through JavaScript. 163 v8::Handle<v8::Value> result = v8::Script::Compile( 164 v8::String::NewFromUtf8(CcTest::isolate(), "(new Foo).get"))->Run(); 165 CHECK_EQ(42, result->Int32Value()); 166 env->Exit(); 167} 168 169 170// CodeRange test. 171// Tests memory management in a CodeRange by allocating and freeing blocks, 172// using a pseudorandom generator to choose block sizes geometrically 173// distributed between 2 * Page::kPageSize and 2^5 + 1 * Page::kPageSize. 174// Ensure that the freed chunks are collected and reused by allocating (in 175// total) more than the size of the CodeRange. 176 177// This pseudorandom generator does not need to be particularly good. 178// Use the lower half of the V8::Random() generator. 179unsigned int Pseudorandom() { 180 static uint32_t lo = 2345; 181 lo = 18273 * (lo & 0xFFFF) + (lo >> 16); // Provably not 0. 182 return lo & 0xFFFF; 183} 184 185 186// Plain old data class. Represents a block of allocated memory. 187class Block { 188 public: 189 Block(Address base_arg, int size_arg) 190 : base(base_arg), size(size_arg) {} 191 192 Address base; 193 int size; 194}; 195 196 197TEST(CodeRange) { 198 const size_t code_range_size = 32*MB; 199 CcTest::InitializeVM(); 200 CodeRange code_range(reinterpret_cast<Isolate*>(CcTest::isolate())); 201 code_range.SetUp(code_range_size); 202 size_t current_allocated = 0; 203 size_t total_allocated = 0; 204 List< ::Block> blocks(1000); 205 206 while (total_allocated < 5 * code_range_size) { 207 if (current_allocated < code_range_size / 10) { 208 // Allocate a block. 209 // Geometrically distributed sizes, greater than 210 // Page::kMaxRegularHeapObjectSize (which is greater than code page area). 211 // TODO(gc): instead of using 3 use some contant based on code_range_size 212 // kMaxHeapObjectSize. 213 size_t requested = 214 (Page::kMaxRegularHeapObjectSize << (Pseudorandom() % 3)) + 215 Pseudorandom() % 5000 + 1; 216 size_t allocated = 0; 217 Address base = code_range.AllocateRawMemory(requested, 218 requested, 219 &allocated); 220 CHECK(base != NULL); 221 blocks.Add(::Block(base, static_cast<int>(allocated))); 222 current_allocated += static_cast<int>(allocated); 223 total_allocated += static_cast<int>(allocated); 224 } else { 225 // Free a block. 226 int index = Pseudorandom() % blocks.length(); 227 code_range.FreeRawMemory(blocks[index].base, blocks[index].size); 228 current_allocated -= blocks[index].size; 229 if (index < blocks.length() - 1) { 230 blocks[index] = blocks.RemoveLast(); 231 } else { 232 blocks.RemoveLast(); 233 } 234 } 235 } 236 237 code_range.TearDown(); 238} 239