| /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...] |
| /dalvik/vm/alloc/ |
| DdmHeap.h | 17 * DDM-specific internal heap functions.
23 * Sends the current heap info to the DDM server.
30 * Walks through the heap and sends a series of
32 * the contents of the GC or native heap.
34 * @param shouldLock If true, grab the heap lock. If false,
35 * the heap lock must already be held.
36 * @param heap If false, dump the GC heap; if true, dump the
37 * native heap.
|
| HeapSource.c | 23 #include "alloc/Heap.h"
65 allocating/freeing: Heap.c just wants to say "alloc(n)" and get a ptr
67 Heap.c will use HeapSource.h; HeapSource.c will do the right thing
80 - that may not work so great for a gc heap, because small will always consume.
84 Find a way to permanently steal pages from the middle of the heap
87 Allocate String and char[] in a separate heap?
89 Maybe avoid growing small heap, even if there's slack? Look at
90 live ratio of small heap after a gc; scale it based on that.
102 /* The bitmap that keeps track of where objects are in the heap.
106 /* The largest size that this heap is allowed to grow to
222 const Heap *const heap = &hs->heaps[i]; local
321 Heap heap; local
394 Heap *heap; local
525 Heap *heap = &hs->heaps[i]; local
565 Heap *const heap = &hs->heaps[i]; local
637 Heap *heap = &hs->heaps[i]; local
654 Heap *heap; local
718 Heap *heap; local
771 Heap *heap; local
796 Heap *heap; local
869 Heap *heap; local
898 Heap *heap; local
924 Heap *heap; local
1200 Heap *heap; local
1311 Heap *heap = &hs->heaps[i]; local
1388 const Heap *heap; local
1427 Heap *heap; local
[all...] |
| Heap.h | 17 * Internal heap functions
23 * Initialize the GC heap.
37 * Tear down the GC heap.
47 * equal to the size of the named object in the heap.
49 * Specifically, it returns the size of the heap
60 /* GC to try to reduce heap footprint to allow more non-GC'ed memory. */
62 /* GC to dump heap contents to a file, only used under WITH_HPROF */
|
| HeapSource.h | 31 * Initializes the heap source; must be called before any other
38 * will create a new heap for post-zygote allocations.
39 * Having a separate heap should maximize the number of pages
46 * will create an additional zygote heap before the first fork().
47 * Having a separate heap should reduce the number of shared
53 * Tears down the heap source and frees any resources associated with it.
77 * Returns the requested value. If the per-heap stats are requested, fill
116 * Returns true iff <ptr> was allocated from the heap source.
136 * Returns the number of bytes that the heap source has allocated
142 * Gets the maximum number of bytes that the heap source is allowe
[all...] |
| /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...] |
| /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...] |
| /external/webkit/WebKit/chromium/src/js/ |
| DevToolsHostStub.js | 127 'heap-sample-begin,"Heap","allocated",' +
129 'heap-sample-stats,"Heap","allocated",10000,1000\n';
131 'heap-sample-item,STRING_TYPE,100,1000\n' +
132 'heap-sample-item,CODE_TYPE,10,200\n' +
133 'heap-sample-item,MAP_TYPE,20,350\n';
136 this.log_ += 'heap-sample-end,"Heap","allocated"\n';
183 'heap-js-cons-item,foo,1,100\n'
[all...] |
| devTools.css | 27 /* Heap Profiler Styles */
29 .heap-snapshot-status-bar-item .glyph {
33 .heap-snapshot-sidebar-tree-item .icon {
37 .heap-snapshot-sidebar-tree-item.small .icon {
41 .heap-snapshot-view {
51 .heap-snapshot-view.visible {
55 .heap-snapshot-view .data-grid {
65 .heap-snapshot-view .data-grid th.count-column {
69 .heap-snapshot-view .data-grid td.count-column {
73 .heap-snapshot-view .data-grid th.size-column
[all...] |
| /dalvik/libcore/dalvik/src/main/java/dalvik/system/ |
| VMRuntime.java | 53 * Gets the current ideal heap utilization, represented as a number
54 * between zero and one. After a GC happens, the Dalvik heap may
55 * be resized so that (size of live objects) / (size of heap) is
58 * @return the current ideal heap utilization
63 * Sets the current ideal heap utilization, represented as a number
64 * between zero and one. After a GC happens, the Dalvik heap may
65 * be resized so that (size of live objects) / (size of heap) is
70 * @param newTarget the new suggested ideal heap utilization.
72 * @return the previous ideal heap utilization
92 * Returns the minimum heap size, or zero if no minimum is in effect
[all...] |
| /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...] |
| 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...] |
| /frameworks/base/core/java/android/ddm/ |
| DdmHandleHeap.java | 30 * Handle native and virtual heap requests.
82 Log.v("ddm-heap", "Handling " + name(request.type) + " chunk");
110 * Handle a "HeaP InFo" request.
117 Log.v("ddm-heap", "Heap segment enable: when=" + when);
128 * Handle a "HeaP SeGment" or "Native Heap SeGment" request.
136 Log.v("ddm-heap", "Heap segment enable: when=" + when
150 * Handle a "HeaP DUmp" request
[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...] |
| ArgList.cpp | 55 // heap, where they do need explicit marking.
57 // We can only register for explicit marking once we know which heap
59 if (Heap* heap = Heap::heap(v)) {
60 ListSet& markSet = heap->markListSet();
|
| /dalvik/docs/ |
| heap-profiling.html | 3 <title>Dalvik Heap Profiling</title>
7 <h1>Dalvik Heap Profiling</h1>
11 of the virtual heap. This is very useful for debugging memory usage
33 You can only generate heap data on the emulator or a device with root
63 The signal causes a GC, followed by the heap dump (to be completely
64 accurate, they actually happen concurrently, but the results in the heap
71 # ls /data/misc/heap-dump*
81 <code>/data/misc/heap-dump-BLAH-BLAH.hprof</code> and
87 $ adb pull /data/misc/heap-dump-BLAH-BLAH.hprof tail.hprof
88 $ adb pull /data/misc/heap-dump-BLAH-BLAH.hprof-head head.hpro
[all...] |
| /external/grub/stage2/ |
| cmdline.c | 117 /* Enter the command-line interface. HEAP is used for the command-line
121 enter_cmdline (char *heap, int forever)
138 *heap = 0;
143 if (get_cmdline (PACKAGE "> ", heap, 2048, 0, 1))
147 if (! heap[0])
151 builtin = find_command (heap);
171 arg = skip_to (1, heap);
179 /* Run an entry from the script SCRIPT. HEAP is used for the
183 run_script (char *script, char *heap)
213 /* Copy the first string in CUR_ENTRY to HEAP. *
[all...] |
| /dalvik/libcore/dalvik/src/main/java/org/apache/harmony/dalvik/ddmc/ |
| DdmVmInternal.java | 35 * Enable heap info updates.
37 * This is built into the VM, since that's where the heap is managed.
46 * Enable heap segment updates for the java (isNative == false) or
47 * native (isNative == true) heap.
49 * This is built into the VM, since that's where the heap is managed.
80 * Fill a buffer with data on recent heap allocations.
|
| /external/bzip2/ |
| huffman.c | 36 zz = z; tmp = heap[zz]; \
37 while (weight[tmp] < weight[heap[zz >> 1]]) { \
38 heap[zz] = heap[zz >> 1]; \
41 heap[zz] = tmp; \
47 zz = z; tmp = heap[zz]; \
52 weight[heap[yy+1]] < weight[heap[yy]]) \
54 if (weight[tmp] < weight[heap[yy]]) break; \
55 heap[zz] = heap[yy];
75 Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ]; local
[all...] |
| /dalvik/vm/compiler/template/armv5te/ |
| TEMPLATE_MEM_OP_DECODE.S | 3 * This handler encapsulates heap memory ops for selfVerification mode.
5 * The call to the handler is inserted prior to a heap memory operation.
|
| /dalvik/vm/compiler/template/armv5te-vfp/ |
| TEMPLATE_MEM_OP_DECODE.S | 3 * This handler encapsulates heap memory ops for selfVerification mode.
5 * The call to the handler is inserted prior to a heap memory operation.
|
