| /external/v8/src/arm/ |
| lithium-codegen-arm.cc | [all...] |
| assembler-arm-inl.h | 221 void RelocInfo::Visit(Heap* heap) {
224 StaticVisitor::VisitPointer(heap, target_object_address());
226 StaticVisitor::VisitCodeTarget(heap, this);
228 StaticVisitor::VisitGlobalPropertyCell(heap, this);
232 } else if (heap->isolate()->debug()->has_break_points() &&
237 StaticVisitor::VisitDebugTarget(heap, this);
|
| /external/v8/test/cctest/ |
| test-heap-profiler.cc | 3 // Tests for heap profiler
8 #include "heap-profiler.h"
146 JSObjectsCluster function(HEAP->function_class_symbol());
152 AddHeapObjectToTree(&tree, HEAP->Object_symbol(), 0x100, &function);
155 AddHeapObjectToTree(&tree, HEAP->Object_symbol(), 0x200, &function);
158 AddHeapObjectToTree(&tree, HEAP->Object_symbol(), 0x300, &a, &b);
161 AddHeapObjectToTree(&tree, HEAP->Object_symbol(), 0x400, &b, &a);
164 AddHeapObjectToTree(&tree, HEAP->Object_symbol(), 0x500,
184 JSObjectsCluster function(HEAP->function_class_symbol());
188 AddHeapObjectToTree(&tree, HEAP->Object_symbol(), 0x100, &function)
[all...] |
| test-serialize.cc | 256 // Test that the whole heap can be serialized.
264 // Test that heap serialization is non-destructive.
274 // Tests that the heap can be deserialized.
284 HEAP->Verify();
288 CHECK(HEAP->symbol_table()->IsSymbolTable());
368 HEAP->CollectAllGarbage(true);
369 HEAP->CollectAllGarbage(true);
429 HEAP->ReserveSpace(new_size,
491 HEAP->CollectAllGarbage(true);
565 HEAP->ReserveSpace
[all...] |
| /external/v8/src/x64/ |
| lithium-codegen-x64.cc | [all...] |
| /external/qemu/distrib/zlib-1.2.3/ |
| trees.c | 92 * need for the L_CODES extra codes used during heap construction. However
427 /* Index within the heap array of least frequent node in the Huffman tree */
431 * Remove the smallest element from the heap and recreate the heap with
432 * one less element. Updates heap and heap_len.
436 top = s->heap[SMALLEST]; \
437 s->heap[SMALLEST] = s->heap[s->heap_len--]; \
450 * Restore the heap property by moving down the tree starting at node k,
452 * when the heap property is re-established (each father smaller than it
[all...] |
| deflate.h | 46 /* maximum heap size */
203 int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ member in struct:internal_state
204 int heap_len; /* number of elements in the heap */
206 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
207 * The same heap array is used to build all trees.
|
| /external/zlib/ |
| trees.c | 93 * need for the L_CODES extra codes used during heap construction. However
431 /* Index within the heap array of least frequent node in the Huffman tree */
435 * Remove the smallest element from the heap and recreate the heap with
436 * one less element. Updates heap and heap_len.
440 top = s->heap[SMALLEST]; \
441 s->heap[SMALLEST] = s->heap[s->heap_len--]; \
454 * Restore the heap property by moving down the tree starting at node k,
456 * when the heap property is re-established (each father smaller than it
[all...] |
| deflate.h | 46 /* maximum heap size */
203 int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ member in struct:internal_state
204 int heap_len; /* number of elements in the heap */
206 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
207 * The same heap array is used to build all trees.
|
| /frameworks/base/docs/html/guide/developing/debugging/ |
| ddms.jd | 20 provides port-forwarding services, screen capture on the device, thread and heap information on
93 <h3>Viewing heap usage for a process</h3>
95 <p>DDMS allows you to view how much heap memory a process is using. This information is useful in
96 tracking heap usage at a certain point of time during the execution of your application.</p>
97 <p>To view heap usage for a process:</p>
99 <li>In the Devices tab, select the process that you want to see the heap information for.</li>
101 <li>Click the <strong>Update Heap</strong> button to enable heap information for the
104 <li>In the Heap tab, click <strong>Cause GC</strong> to invoke garbage collection, which
105 enables the collection of heap data. When the operation completes, you will see a group o
[all...] |
| /dalvik/vm/analysis/ |
| RegisterMap.h | 38 kRegMapFormatOnHeap = 0x80, /* bit flag, indicates allocation on heap */
43 * heap or mapped out of a (post-dexopt) DEX file.
83 * Get the "on heap" flag.
104 * Set the "on heap" flag.
143 * single line onto the heap, this will free "data"; otherwise, it does
|
| /external/chromium/base/allocator/ |
| allocator_shim.cc | 9 // When defined, different heap allocators can be used via an environment
35 WINHEAP, // Windows Heap (standard Windows allocator).
36 WINLFH, // Windows LFH Heap.
230 // The CRT heap initialization stub.
266 // The CRT heap cleanup stub.
|
| /external/valgrind/main/massif/tests/ |
| deep-A.post.exp | 36 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
48 98.04% (3,600B) (heap allocation functions) malloc/new/new[], --alloc-fns, etc.
59 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
|
| deep-B.post.exp | 36 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
48 98.04% (3,600B) (heap allocation functions) malloc/new/new[], --alloc-fns, etc.
57 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
|
| deep-C.post.exp | 36 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
48 98.04% (3,600B) (heap allocation functions) malloc/new/new[], --alloc-fns, etc.
54 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
|
| deep-D.post.exp | 36 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
48 98.04% (3,600B) (heap allocation functions) malloc/new/new[], --alloc-fns, etc.
52 n time(B) total(B) useful-heap(B) extra-heap(B) stacks(B)
|
| /frameworks/base/libs/gui/ |
| ISurfaceComposer.cpp | 104 sp<IMemoryHeap>* heap,
117 *heap = interface_cast<IMemoryHeap>(reply.readStrongBinder());
225 sp<IMemoryHeap> heap; local
228 status_t res = captureScreen(dpy, &heap, &w, &h, &f,
230 reply->writeStrongBinder(heap->asBinder());
|
| /prebuilt/linux-x86/toolchain/i686-linux-glibc2.7-4.4.3/i686-linux/include/c++/4.4.3/ext/pb_ds/ |
| tag_and_trait.hpp | 140 /// Pairing-heap.
143 /// Binomial-heap.
146 /// Redundant-counter binomial-heap.
149 /// Binary-heap (array-based).
152 /// Thin heap.
|
| /prebuilt/ndk/android-ndk-r5/sources/cxx-stl/gnu-libstdc++/include/ext/pb_ds/ |
| tag_and_trait.hpp | 140 /// Pairing-heap.
143 /// Binomial-heap.
146 /// Redundant-counter binomial-heap.
149 /// Binary-heap (array-based).
152 /// Thin heap.
|
| /prebuilt/ndk/android-ndk-r6/sources/cxx-stl/gnu-libstdc++/include/ext/pb_ds/ |
| tag_and_trait.hpp | 140 /// Pairing-heap.
143 /// Binomial-heap.
146 /// Redundant-counter binomial-heap.
149 /// Binary-heap (array-based).
152 /// Thin heap.
|
| /external/v8/src/ |
| liveobjectlist.cc | 37 #include "heap.h"
215 return Heap::InSpace(heap_obj, space);
220 // here are guaranteed to be in the heap. Hence, it is safe to infer
222 // Note: calling Heap::InSpace(heap_obj, LO_SPACE) is too slow for our
227 if (Heap::InSpace(heap_obj, static_cast<AllocationSpace>(sp))) {
231 SLOW_ASSERT(Heap::InSpace(heap_obj, LO_SPACE));
971 // The heap must have grown and we have more objects than capacity to store
1077 // Counts the number of objects in the heap.
1080 // Iterate over all the heap spaces and count the number of objects
[all...] |
| objects-debug.cc | 181 ASSERT(HEAP->Contains(HeapObject::cast(p)));
251 ASSERT(!HEAP->InNewSpace(this));
255 instance_size() < HEAP->Capacity()));
318 CHECK(!HEAP->InNewSpace(this));
382 ASSERT(number == HEAP->nan_value());
593 Heap* heap = HEAP; local
595 if (e->get(i) == heap->the_hole_value()) holes++;
|
| /external/webkit/Source/JavaScriptCore/runtime/ |
| JSGlobalObject.cpp | 106 m_globalData = Heap::heap(this)->globalData();
120 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
129 ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this))
[all...] |
| /external/clang/docs/ |
| BlockLanguageSpec.txt | 19 A new derived type is introduced to C and, by extension, Objective-C, C++, and Objective-C++. Like function types, the Block type is a pair consisting of a result value type and a list of parameter types very similar to a function type. Blocks are intended to be used much like functions with the key distinction being that in addition to executable code they also contain various variable bindings to automatic (stack) or managed (heap) memory.
21 The abstract declarator int (^)(char, float) describes a reference to a Block that, when invoked, takes two parameters, the first of type char and the second of type float, and returns a value of type int. The Block referenced is of opaque data that may reside in automatic (stack) memory, global memory, or heap memory.
113 In addition to the new Block type we also introduce a new storage qualifier, __block, for local variables. [testme: a __block declaration within a block literal] The __block storage qualifier is mutually exclusive to the existing local storage qualifiers auto, register, and static.[testme] Variables qualified by __block act as if they were in allocated storage and this storage is automatically recovered after last use of said variable. An implementation may choose an optimization where the storage is initially automatic and only "moved" to allocated (heap) storage upon a Block_copy of a referencing Block. Such variables may be mutated as normal variables are.
137 In garbage collected environments, the __weak variable is set to nil when the object it references is collected, as long as the __block variable resides in the heap (either by default or via Block_copy()). The initial Apple implementation does in fact start __block variables on the stack and migrate them to the heap only as a result of a Block_copy() operation.
158 If a Block originates on the stack, a const copy constructor of the stack-based Block const copy is performed when a Block_copy operation is called; when the last Block_release (or subsequently GC) occurs, a destructor is run on the heap copy.
160 Variables declared as residing in __block storage may be initially allocated in the heap or may first appear on the stack and be copied to the heap as a result of a Block_copy() operation. When copied from the stack, a normal copy constructor is used to initialize the heap-based version from the original stack version. The destructor for a const copied object is run at the normal end of scope. The destructor for any initial stack based version is also called at normal end of scope.
|
| /external/icu4c/test/intltest/ |
| itspoof.cpp | 145 // A long "identifier" that will overflow implementation stack buffers, forcing heap allocations.
146 CHECK_SKELETON(SL, " A 1ong \\u02b9identifier' that will overflow implementation stack buffers, forcing heap allocations."
147 " A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations."
148 " A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations."
149 " A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations.",
151 " A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations."
152 " A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations."
153 " A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations."
154 " A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations.")
|
