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