| /external/v8/test/cctest/ |
| test-mark-compact.cc | 78 Heap::ConfigureHeap(2*256*KB, 4*MB);
86 (Heap::MaxObjectSizeInPagedSpace() - FixedArray::kHeaderSize) /
88 Object* obj = Heap::AllocateFixedArray(array_size);
94 CHECK(Heap::InSpace(*array, NEW_SPACE));
97 CHECK(Heap::CollectGarbage(0, OLD_POINTER_SPACE));
100 CHECK(Heap::InSpace(*array, OLD_POINTER_SPACE));
105 Heap::ConfigureHeap(2*256*KB, 4*MB);
113 // Do a mark compact GC to shrink the heap.
114 CHECK(Heap::CollectGarbage(0, OLD_POINTER_SPACE));
117 int size = (Heap::MaxObjectSizeInPagedSpace() - FixedArray::kHeaderSize)
[all...] |
| test-heap.cc | 27 CHECK(Heap::Contains(map));
29 CHECK_EQ(Heap::meta_map(), map->map());
37 CheckMap(Heap::meta_map(), MAP_TYPE, Map::kSize);
38 CheckMap(Heap::heap_number_map(), HEAP_NUMBER_TYPE, HeapNumber::kSize);
39 CheckMap(Heap::fixed_array_map(), FIXED_ARRAY_TYPE, FixedArray::kHeaderSize);
40 CheckMap(Heap::string_map(), STRING_TYPE, SeqTwoByteString::kAlignedSize);
61 Object* obj = Heap::NumberFromDouble(value);
79 Object* code = Heap::CreateCode(desc,
82 Handle<Object>(Heap::undefined_value()));
89 Object* found = Heap::FindCodeObject(obj_addr + i)
[all...] |
| test-alloc.cc | 43 NewSpace* new_space = Heap::new_space();
47 CHECK(!Heap::AllocateByteArray(0)->IsFailure());
55 CHECK(!Heap::AllocateByteArray(100)->IsFailure());
56 CHECK(!Heap::AllocateFixedArray(100, NOT_TENURED)->IsFailure());
60 CHECK(!Heap::AllocateFixedArray(100)->IsFailure());
61 CHECK(!Heap::AllocateHeapNumber(0.42)->IsFailure());
62 CHECK(!Heap::AllocateArgumentsObject(Smi::FromInt(87), 10)->IsFailure());
63 Object* object = Heap::AllocateJSObject(*Top::object_function());
64 CHECK(!Heap::CopyJSObject(JSObject::cast(object))->IsFailure());
67 OldSpace* old_data_space = Heap::old_data_space()
[all...] |
| test-spaces.cc | 101 CHECK(Heap::ConfigureHeapDefault());
102 CHECK(MemoryAllocator::Setup(Heap::MaxReserved()));
104 OldSpace faked_space(Heap::MaxReserved(), OLD_POINTER_SPACE, NOT_EXECUTABLE);
157 CHECK(Heap::ConfigureHeapDefault());
158 CHECK(MemoryAllocator::Setup(Heap::MaxReserved()));
163 MemoryAllocator::ReserveInitialChunk(4 * Heap::ReservedSemiSpaceSize());
166 2 * Heap::ReservedSemiSpaceSize());
167 CHECK(new_space.Setup(start, 2 * Heap::ReservedSemiSpaceSize()));
182 CHECK(Heap::ConfigureHeapDefault());
183 CHECK(MemoryAllocator::Setup(Heap::MaxReserved()))
[all...] |
| test-assembler-ia32.cc | 72 Object* code = Heap::CreateCode(desc,
75 Handle<Object>(Heap::undefined_value()));
110 Object* code = Heap::CreateCode(desc,
113 Handle<Object>(Heap::undefined_value()));
152 Object* code = Heap::CreateCode(desc,
155 Handle<Object>(Heap::undefined_value()));
185 Code::cast(Heap::CreateCode(desc,
188 Handle<Object>(Heap::undefined_value())));
218 Code::cast(Heap::CreateCode(desc,
221 Handle<Object>(Heap::undefined_value())))
[all...] |
| test-heap-profiler.cc | 3 // Tests for heap profiler
8 #include "heap-profiler.h"
150 JSObjectsCluster function(i::Heap::function_class_symbol());
156 AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x100, &function);
159 AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x200, &function);
162 AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x300, &a, &b);
165 AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x400, &b, &a);
168 AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x500,
189 JSObjectsCluster function(i::Heap::function_class_symbol());
193 AddHeapObjectToTree(&tree, i::Heap::Object_symbol(), 0x100, &function)
[all...] |
| /external/webkit/WebCore/bindings/js/ |
| JSMessageChannelCustom.cpp | 40 markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port);
43 markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port);
|
| JSCSSRuleListCustom.cpp | 40 JSGlobalData& globalData = *Heap::heap(this)->globalData();
|
| JSSharedWorkerCustom.cpp | 49 markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port);
|
| /dalvik/hit/src/com/android/hit/ |
| State.java | 26 * During parsing of the HPROF file HEAP_DUMP_INFO chunks change which heap
30 HashMap<Integer, Heap> mHeaps;
31 Heap mCurrentHeap;
34 mHeaps = new HashMap<Integer, Heap>();
38 public Heap setToDefaultHeap() {
42 public Heap setHeapTo(int id, String name) {
43 Heap heap = mHeaps.get(id); local
45 if (heap == null) {
46 heap = new Heap(name)
[all...] |
| Instance.java | 32 // The heap in which this object was allocated (app, zygote, etc)
33 Heap mHeap;
47 * called on all heap objects so that they can resolve their internal
52 * for in a heap other than the one this Instance is in.
89 public void setHeap(Heap heap) {
90 mHeap = heap;
|
| /external/v8/src/ |
| heap-inl.h | 37 int Heap::MaxObjectSizeInPagedSpace() {
42 Object* Heap::AllocateSymbol(Vector<const char> str,
51 Object* Heap::AllocateRaw(int size_in_bytes,
62 Heap::allocation_timeout_-- <= 0) {
97 Object* Heap::NumberFromInt32(int32_t value) {
104 Object* Heap::NumberFromUint32(uint32_t value) {
113 void Heap::FinalizeExternalString(String* string) {
126 Object* Heap::AllocateRawMap() {
143 Object* Heap::AllocateRawCell() {
154 bool Heap::InNewSpace(Object* object)
[all...] |
| mark-compact.cc | 119 if (!Heap::map_space()->MapPointersEncodable())
195 // Marking all live objects in the heap as part of mark-sweep or mark-compact
214 // the heap looking for objects marked as overflowed, push them on the stack,
222 // Optimization: If the heap object pointed to by p is a non-symbol
223 // cons string whose right substring is Heap::empty_string, update
226 // Here we assume that if we change *p, we replace it with a heap object
227 // (ie, the left substring of a cons string is always a heap object).
231 // (ConsString::cast(object)->second() == Heap::empty_string())
241 if (second != Heap::raw_unchecked_empty_string()) {
249 if (!Heap::InNewSpace(object) && Heap::InNewSpace(first)) return object
[all...] |
| heap.cc | 36 #include "heap-profiler.h"
53 String* Heap::hidden_symbol_;
54 Object* Heap::roots_[Heap::kRootListLength];
57 NewSpace Heap::new_space_;
58 OldSpace* Heap::old_pointer_space_ = NULL;
59 OldSpace* Heap::old_data_space_ = NULL;
60 OldSpace* Heap::code_space_ = NULL;
61 MapSpace* Heap::map_space_ = NULL;
62 CellSpace* Heap::cell_space_ = NULL
[all...] |
| log-inl.h | 65 // When not protecting the heap, there is no difference between
87 Heap::Protect();
90 Heap::Unprotect();
113 Heap::Unprotect();
116 Heap::Protect();
|
| code-stubs.cc | 41 int index = Heap::code_stubs()->FindEntry(GetKey());
43 *code_out = Code::cast(Heap::code_stubs()->ValueAt(index));
99 // Copy the generated code into a heap object.
108 // Update the dictionary and the root in Heap.
111 Handle<NumberDictionary>(Heap::code_stubs()),
114 Heap::public_set_code_stubs(*dict);
134 // Try to copy the generated code into a heap object.
137 Heap::CreateCode(desc, NULL, flags, masm.CodeObject());
146 new_object = Heap::code_stubs()->AtNumberPut(GetKey(), code);
148 Heap::public_set_code_stubs(NumberDictionary::cast(new_object))
[all...] |
| factory.cc | 42 CALL_HEAP_FUNCTION(Heap::AllocateFixedArray(size, pretenure), FixedArray);
48 CALL_HEAP_FUNCTION(Heap::AllocateFixedArrayWithHoles(size), FixedArray);
75 CALL_HEAP_FUNCTION(Heap::LookupSymbol(string), String);
81 CALL_HEAP_FUNCTION(Heap::AllocateStringFromAscii(string, pretenure), String);
86 CALL_HEAP_FUNCTION(Heap::AllocateStringFromUtf8(string, pretenure), String);
92 CALL_HEAP_FUNCTION(Heap::AllocateStringFromTwoByte(string, pretenure),
99 CALL_HEAP_FUNCTION(Heap::AllocateRawTwoByteString(length, pretenure), String);
105 CALL_HEAP_FUNCTION(Heap::AllocateConsString(*first, *second), String);
118 CALL_HEAP_FUNCTION(Heap::AllocateExternalStringFromAscii(resource), String);
124 CALL_HEAP_FUNCTION(Heap::AllocateExternalStringFromTwoByte(resource), String)
[all...] |
| v8.cc | 60 // Enable logging before setting up the heap
79 // Setup the object heap
80 ASSERT(!Heap::HasBeenSetup());
81 if (!Heap::Setup(create_heap_objects)) {
100 // If we are deserializing, read the state into the now-empty heap.
108 Heap::SetStackLimits();
110 // Setup the CPU support. Must be done after heap setup and after
111 // any deserialization because we have to have the initial heap
150 Heap::TearDown();
182 // Tell the heap that it may want to adjust
[all...] |
| runtime.cc | 103 Object* result = Heap::CopyJSObject(boilerplate);
130 result = Heap::AllocateFixedArray(copy->NumberOfLocalProperties(NONE));
205 return Heap::CopyJSObject(boilerplate);
407 if (*boilerplate == Heap::undefined_value()) {
426 if (*boilerplate == Heap::undefined_value()) {
432 return Heap::CopyJSObject(JSObject::cast(*boilerplate));
445 if (*boilerplate == Heap::undefined_value()) {
464 if (*boilerplate == Heap::undefined_value()) {
470 return Heap::CopyJSObject(JSObject::cast(*boilerplate));
481 Object* object = Heap::AllocateJSObject(constructor)
[all...] |
| /external/webkit/JavaScriptCore/runtime/ |
| Collector.h | 69 class Heap : public Noncopyable {
96 static Heap* heap(JSValue); // 0 for immediate values
97 static Heap* heap(JSCell*);
105 void registerThread(); // Only needs to be called by clients that can use the same heap from multiple threads.
127 Heap(JSGlobalData*);
128 ~Heap();
200 const size_t CELLS_PER_BLOCK = (BLOCK_SIZE - sizeof(Heap*)) * 8 * CELL_SIZE / (8 * CELL_SIZE + 1) / CELL_SIZE; // one bitmap byte can represent 8 cells.
239 Heap* heap member in class:JSC::CollectorBlock
[all...] |
| Collector.cpp | 113 const size_t MAX_NUM_BLOCKS = 256; // Max size of collector heap set to 16 MB
125 class Heap::Thread {
142 Heap::Heap(JSGlobalData* globalData)
157 // of alignment value for (symbian) cells within that heap.
176 Heap::~Heap()
182 void Heap::destroy()
208 for (Heap::Thread* t = m_registeredThreads; t;) {
209 Heap::Thread* next = t->next
[all...] |
| JSActivation.cpp | 96 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
111 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this))
[all...] |
| JSVariableObject.h | 127 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
140 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this))
[all...] |
| WeakGCMap.h | 80 if (!Heap::isCellMarked(result))
91 if (!Heap::isCellMarked(result))
99 Heap::markCell(value); // If value is newly allocated, it's not marked, so mark it now.
102 result.second = !Heap::isCellMarked(result.first->second);
|
| /external/srec/tools/thirdparty/OpenFst/fst/lib/ |
| heap.h | 0 // heap.h
17 // Implementation of a heap as in STL, but allows tracking positions
18 // in heap using a key. The key can be used to do an in place update of
19 // values in the heap.
30 // \class Heap
31 // \brief A templated heap implementation that support in place update
34 // The templated heap implementation is a little different from the
35 // STL priority_queue and the *_heap operations in STL. The heap
36 // supports indexing of values in the heap via an associated key.
39 // to the calling functions on heap insert. This key can be use
[all...] |
