1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <err.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <inttypes.h>
21 #include <malloc.h>
22 #include <stdint.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/stat.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29
30 #include "Alloc.h"
31 #include "File.h"
32 #include "NativeInfo.h"
33 #include "Pointers.h"
34 #include "Thread.h"
35 #include "Threads.h"
36
37 constexpr size_t kDefaultMaxThreads = 512;
38
GetMaxAllocs(const AllocEntry * entries,size_t num_entries)39 static size_t GetMaxAllocs(const AllocEntry* entries, size_t num_entries) {
40 size_t max_allocs = 0;
41 size_t num_allocs = 0;
42 for (size_t i = 0; i < num_entries; i++) {
43 switch (entries[i].type) {
44 case THREAD_DONE:
45 break;
46 case MALLOC:
47 case CALLOC:
48 case MEMALIGN:
49 if (entries[i].ptr != 0) {
50 num_allocs++;
51 }
52 break;
53 case REALLOC:
54 if (entries[i].ptr == 0 && entries[i].u.old_ptr != 0) {
55 num_allocs--;
56 } else if (entries[i].ptr != 0 && entries[i].u.old_ptr == 0) {
57 num_allocs++;
58 }
59 break;
60 case FREE:
61 if (entries[i].ptr != 0) {
62 num_allocs--;
63 }
64 break;
65 }
66 if (num_allocs > max_allocs) {
67 max_allocs = num_allocs;
68 }
69 }
70 return max_allocs;
71 }
72
ProcessDump(const AllocEntry * entries,size_t num_entries,size_t max_threads)73 static void ProcessDump(const AllocEntry* entries, size_t num_entries, size_t max_threads) {
74 // Do a pass to get the maximum number of allocations used at one
75 // time to allow a single mmap that can hold the maximum number of
76 // pointers needed at once.
77 size_t max_allocs = GetMaxAllocs(entries, num_entries);
78 Pointers pointers(max_allocs);
79 Threads threads(&pointers, max_threads);
80
81 NativePrintf("Maximum threads available: %zu\n", threads.max_threads());
82 NativePrintf("Maximum allocations in dump: %zu\n", max_allocs);
83 NativePrintf("Total pointers available: %zu\n\n", pointers.max_pointers());
84
85 NativePrintInfo("Initial ");
86
87 for (size_t i = 0; i < num_entries; i++) {
88 if (((i + 1) % 100000) == 0) {
89 NativePrintf(" At line %zu:\n", i + 1);
90 NativePrintInfo(" ");
91 }
92 const AllocEntry& entry = entries[i];
93 Thread* thread = threads.FindThread(entry.tid);
94 if (thread == nullptr) {
95 thread = threads.CreateThread(entry.tid);
96 }
97
98 // Wait for the thread to complete any previous actions before handling
99 // the next action.
100 thread->WaitForReady();
101
102 thread->SetAllocEntry(&entry);
103
104 bool does_free = AllocDoesFree(entry);
105 if (does_free) {
106 // Make sure that any other threads doing allocations are complete
107 // before triggering the action. Otherwise, another thread could
108 // be creating the allocation we are going to free.
109 threads.WaitForAllToQuiesce();
110 }
111
112 // Tell the thread to execute the action.
113 thread->SetPending();
114
115 if (entries[i].type == THREAD_DONE) {
116 // Wait for the thread to finish and clear the thread entry.
117 threads.Finish(thread);
118 }
119
120 // Wait for this action to complete. This avoids a race where
121 // another thread could be creating the same allocation where are
122 // trying to free.
123 if (does_free) {
124 thread->WaitForReady();
125 }
126 }
127 // Wait for all threads to stop processing actions.
128 threads.WaitForAllToQuiesce();
129
130 NativePrintInfo("Final ");
131
132 // Free any outstanding pointers.
133 // This allows us to run a tool like valgrind to verify that no memory
134 // is leaked and everything is accounted for during a run.
135 threads.FinishAll();
136 pointers.FreeAll();
137
138 // Print out the total time making all allocation calls.
139 char buffer[256];
140 uint64_t total_nsecs = threads.total_time_nsecs();
141 NativeFormatFloat(buffer, sizeof(buffer), total_nsecs, 1000000000);
142 NativePrintf("Total Allocation/Free Time: %" PRIu64 "ns %ss\n", total_nsecs, buffer);
143 }
144
main(int argc,char ** argv)145 int main(int argc, char** argv) {
146 if (argc != 2 && argc != 3) {
147 if (argc > 3) {
148 fprintf(stderr, "Only two arguments are expected.\n");
149 } else {
150 fprintf(stderr, "Requires at least one argument.\n");
151 }
152 fprintf(stderr, "Usage: %s MEMORY_LOG_FILE [MAX_THREADS]\n", basename(argv[0]));
153 fprintf(stderr, " MEMORY_LOG_FILE\n");
154 fprintf(stderr, " This can either be a text file or a zipped text file.\n");
155 fprintf(stderr, " MAX_THREADs\n");
156 fprintf(stderr, " The maximum number of threads in the trace. The default is %zu.\n",
157 kDefaultMaxThreads);
158 fprintf(stderr, " This pre-allocates the memory for thread data to avoid allocating\n");
159 fprintf(stderr, " while the trace is being replayed.\n");
160 return 1;
161 }
162
163 #if defined(__LP64__)
164 NativePrintf("64 bit environment.\n");
165 #else
166 NativePrintf("32 bit environment.\n");
167 #endif
168
169 #if defined(__BIONIC__)
170 NativePrintf("Setting decay time to 1\n");
171 mallopt(M_DECAY_TIME, 1);
172 #endif
173
174 size_t max_threads = kDefaultMaxThreads;
175 if (argc == 3) {
176 max_threads = atoi(argv[2]);
177 }
178
179 AllocEntry* entries;
180 size_t num_entries;
181 GetUnwindInfo(argv[1], &entries, &num_entries);
182
183 NativePrintf("Processing: %s\n", argv[1]);
184
185 ProcessDump(entries, num_entries, max_threads);
186
187 FreeEntries(entries, num_entries);
188
189 return 0;
190 }
191