1 //--------------------------------------------------------------------*/
2 //--- Massif: a heap profiling tool. ms_main.c ---*/
3 //--------------------------------------------------------------------*/
6 This file is part of Massif, a Valgrind tool for profiling memory
9 Copyright (C) 2003-2017 Nicholas Nethercote
12 This program is free software; you can redistribute it and/or
13 modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation; either version 2 of the
15 License, or (at your option) any later version.
17 This program is distributed in the hope that it will be useful, but
18 WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 The GNU General Public License is contained in the file COPYING.
30 //---------------------------------------------------------------------------
32 //---------------------------------------------------------------------------
33 // Todo -- nice, but less critical:
34 // - do a graph-drawing test
35 // - make file format more generic. Obstacles:
36 // - unit prefixes are not generic
37 // - preset column widths for stats are not generic
38 // - preset column headers are not generic
39 // - "Massif arguments:" line is not generic
40 // - do snapshots on some specific client requests
41 // - "show me the extra allocations since the last snapshot"
42 // - "start/stop logging" (eg. quickly skip boring bits)
43 // - Add ability to draw multiple graphs, eg. heap-only, stack-only, total.
44 // Give each graph a title. (try to do it generically!)
45 // - make --show-below-main=no work
46 // - Options like --alloc-fn='operator new(unsigned, std::nothrow_t const&)'
47 // don't work in a .valgrindrc file or in $VALGRIND_OPTS.
48 // m_commandline.c:add_args_from_string() needs to respect single quotes.
49 // - With --stack=yes, want to add a stack trace for detailed snapshots so
50 // it's clear where/why the peak is occurring. (Mattieu Castet) Also,
51 // possibly useful even with --stack=no? (Andi Yin)
54 // - To run the benchmarks:
56 // perl perf/vg_perf --tools=massif --reps=3 perf/{heap,tinycc} massif
57 // time valgrind --tool=massif --depth=100 konqueror
59 // The other benchmarks don't do much allocation, and so give similar speeds
62 // Timing results on 'nevermore' (njn's machine) as of r7013:
64 // heap 0.53s ma:12.4s (23.5x, -----)
65 // tinycc 0.46s ma: 4.9s (10.7x, -----)
66 // many-xpts 0.08s ma: 2.0s (25.0x, -----)
67 // konqueror 29.6s real 0:21.0s user
69 // [Introduction of --time-unit=i as the default slowed things down by
72 // Todo -- low priority:
73 // - In each XPt, record both bytes and the number of allocations, and
74 // possibly the global number of allocations.
75 // - (Andy Lin) Give a stack trace on detailed snapshots?
76 // - (Artur Wisz) add a feature to Massif to ignore any heap blocks larger
77 // than a certain size! Because: "linux's malloc allows to set a
78 // MMAP_THRESHOLD value, so we set it to 4096 - all blocks above that will
79 // be handled directly by the kernel, and are guaranteed to be returned to
80 // the system when freed. So we needed to profile only blocks below this
83 // File format working notes:
86 desc
: --heap
-admin
=foo
105 n1
: 5 (heap allocation functions
) malloc
/new/new[], --alloc
-fns
, etc
.
106 n1
: 5 0x27F6E0: _nl_normalize_codeset (in
/lib
/libc
-2.3.5.so
)
107 n1
: 5 0x279DE6: _nl_load_locale_from_archive (in
/lib
/libc
-2.3.5.so
)
108 n1
: 5 0x278E97: _nl_find_locale (in
/lib
/libc
-2.3.5.so
)
109 n1
: 5 0x278871: setlocale (in
/lib
/libc
-2.3.5.so
)
110 n1
: 5 0x8049821: (within
/bin
/date
)
111 n0
: 5 0x26ED5E: (below main
) (in
/lib
/libc
-2.3.5.so
)
114 n_events
: n
time(ms
) total(B
) useful
-heap(B
) admin
-heap(B
) stacks(B
)
122 - each snapshot specifies an x
-axis value
and one
or more y
-axis values
.
123 - can display the y
-axis values separately
if you like
124 - can completely separate connection between snapshots
and trees
.
127 - how to specify
and scale
/abbreviate units on axes
?
128 - how to combine multiple values into the y
-axis
?
130 --------------------------------------------------------------------------------Command
: date
131 Massif arguments
: --heap
-admin
=foo
132 ms_print arguments
: massif
.out
133 --------------------------------------------------------------------------------
138 | ::@
:@
:@
:@
:::# :: : ::::
139 0 +-----------------------------------@
---@
---@
-----@
--@
---#-------------->ms 0 713
141 Number of snapshots
: 50
142 Detailed snapshots
: [2, 11, 13, 19, 25, 32 (peak
)]
143 -------------------------------------------------------------------------------- n
time(ms
) total(B
) useful
-heap(B
) admin
-heap(B
) stacks(B
)
144 -------------------------------------------------------------------------------- 0 0 0 0 0 0
147 100.00% (5B
) (heap allocation functions
) malloc
/new/new[], --alloc
-fns
, etc
.
148 ->100.00% (5B
) 0x27F6E0: _nl_normalize_codeset (in
/lib
/libc
-2.3.5.so
)
151 //---------------------------------------------------------------------------
153 #include "pub_tool_basics.h"
154 #include "pub_tool_vki.h"
155 #include "pub_tool_aspacemgr.h"
156 #include "pub_tool_debuginfo.h"
157 #include "pub_tool_hashtable.h"
158 #include "pub_tool_libcbase.h"
159 #include "pub_tool_libcassert.h"
160 #include "pub_tool_libcfile.h"
161 #include "pub_tool_libcprint.h"
162 #include "pub_tool_libcproc.h"
163 #include "pub_tool_machine.h"
164 #include "pub_tool_mallocfree.h"
165 #include "pub_tool_options.h"
166 #include "pub_tool_poolalloc.h"
167 #include "pub_tool_replacemalloc.h"
168 #include "pub_tool_stacktrace.h"
169 #include "pub_tool_threadstate.h"
170 #include "pub_tool_tooliface.h"
171 #include "pub_tool_xarray.h"
172 #include "pub_tool_xtree.h"
173 #include "pub_tool_xtmemory.h"
174 #include "pub_tool_clientstate.h"
175 #include "pub_tool_gdbserver.h"
177 #include "pub_tool_clreq.h" // For {MALLOC,FREE}LIKE_BLOCK
179 //------------------------------------------------------------*/
180 //--- Overview of operation ---*/
181 //------------------------------------------------------------*/
183 // The size of the stacks and heap is tracked. The heap is tracked in a lot
184 // of detail, enough to tell how many bytes each line of code is responsible
185 // for, more or less. The main data structure is an xtree maintaining the
186 // call tree beneath all the allocation functions like malloc().
187 // (Alternatively, if --pages-as-heap=yes is specified, memory is tracked at
188 // the page level, and each page is treated much like a heap block. We use
189 // "heap" throughout below to cover this case because the concepts are all the
192 // "Snapshots" are recordings of the memory usage. There are two basic
194 // - Normal: these record the current time, total memory size, total heap
195 // size, heap admin size and stack size.
196 // - Detailed: these record those things in a normal snapshot, plus a very
197 // detailed XTree (see below) indicating how the heap is structured.
199 // Snapshots are taken every so often. There are two storage classes of
201 // - Temporary: Massif does a temporary snapshot every so often. The idea
202 // is to always have a certain number of temporary snapshots around. So
203 // we take them frequently to begin with, but decreasingly often as the
204 // program continues to run. Also, we remove some old ones after a while.
205 // Overall it's a kind of exponential decay thing. Most of these are
206 // normal snapshots, a small fraction are detailed snapshots.
207 // - Permanent: Massif takes a permanent (detailed) snapshot in some
208 // circumstances. They are:
209 // - Peak snapshot: When the memory usage peak is reached, it takes a
210 // snapshot. It keeps this, unless the peak is subsequently exceeded,
211 // in which case it will overwrite the peak snapshot.
212 // - User-requested snapshots: These are done in response to client
213 // requests. They are always kept.
215 // Used for printing things when clo_verbosity > 1.
216 #define VERB(verb, format, args...) \
217 if (UNLIKELY(VG_(clo_verbosity) > verb)) { \
218 VG_(dmsg)("Massif: " format, ##args); \
221 //------------------------------------------------------------//
222 //--- Statistics ---//
223 //------------------------------------------------------------//
225 // Konqueror startup, to give an idea of the numbers involved with a biggish
226 // program, with default depth:
229 // - 310,000 allocations
231 // - 15,000 XPts 800,000 XPts
234 static UInt n_heap_allocs
= 0;
235 static UInt n_heap_reallocs
= 0;
236 static UInt n_heap_frees
= 0;
237 static UInt n_ignored_heap_allocs
= 0;
238 static UInt n_ignored_heap_frees
= 0;
239 static UInt n_ignored_heap_reallocs
= 0;
240 static UInt n_stack_allocs
= 0;
241 static UInt n_stack_frees
= 0;
243 static UInt n_skipped_snapshots
= 0;
244 static UInt n_real_snapshots
= 0;
245 static UInt n_detailed_snapshots
= 0;
246 static UInt n_peak_snapshots
= 0;
247 static UInt n_cullings
= 0;
249 //------------------------------------------------------------//
251 //------------------------------------------------------------//
253 // Number of guest instructions executed so far. Only used with
255 static Long guest_instrs_executed
= 0;
257 static SizeT heap_szB
= 0; // Live heap size
258 static SizeT heap_extra_szB
= 0; // Live heap extra size -- slop + admin bytes
259 static SizeT stacks_szB
= 0; // Live stacks size
261 // This is the total size from the current peak snapshot, or 0 if no peak
262 // snapshot has been taken yet.
263 static SizeT peak_snapshot_total_szB
= 0;
265 // Incremented every time memory is allocated/deallocated, by the
266 // allocated/deallocated amount; includes heap, heap-admin and stack
267 // memory. An alternative to milliseconds as a unit of program "time".
268 static ULong total_allocs_deallocs_szB
= 0;
270 // When running with --heap=yes --pages-as-heap=no, we don't start taking
271 // snapshots until the first basic block is executed, rather than doing it in
272 // ms_post_clo_init (which is the obvious spot), for two reasons.
273 // - It lets us ignore stack events prior to that, because they're not
274 // really proper ones and just would screw things up.
275 // - Because there's still some core initialisation to do, and so there
276 // would be an artificial time gap between the first and second snapshots.
278 // When running with --heap=yes --pages-as-heap=yes, snapshots start much
279 // earlier due to new_mem_startup so this isn't relevant.
281 static Bool have_started_executing_code
= False
;
283 //------------------------------------------------------------//
284 //--- Alloc fns ---//
285 //------------------------------------------------------------//
287 static XArray
* alloc_fns
;
288 static XArray
* ignore_fns
;
290 static void init_alloc_fns(void)
292 // Create the list, and add the default elements.
293 alloc_fns
= VG_(newXA
)(VG_(malloc
), "ms.main.iaf.1",
294 VG_(free
), sizeof(HChar
*));
295 #define DO(x) { const HChar* s = x; VG_(addToXA)(alloc_fns, &s); }
297 // Ordered roughly according to (presumed) frequency.
298 // Nb: The C++ "operator new*" ones are overloadable. We include them
299 // always anyway, because even if they're overloaded, it would be a
300 // prodigiously stupid overloading that caused them to not allocate
303 // XXX: because we don't look at the first stack entry (unless it's a
304 // custom allocation) there's not much point to having all these alloc
305 // functions here -- they should never appear anywhere (I think?) other
306 // than the top stack entry. The only exceptions are those that in
307 // vg_replace_malloc.c are partly or fully implemented in terms of another
308 // alloc function: realloc (which uses malloc); valloc,
309 // malloc_zone_valloc, posix_memalign and memalign_common (which use
313 DO("__builtin_new" );
314 DO("operator new(unsigned)" );
315 DO("operator new(unsigned long)" );
316 DO("__builtin_vec_new" );
317 DO("operator new[](unsigned)" );
318 DO("operator new[](unsigned long)" );
322 DO("posix_memalign" );
324 DO("operator new(unsigned, std::nothrow_t const&)" );
325 DO("operator new[](unsigned, std::nothrow_t const&)" );
326 DO("operator new(unsigned long, std::nothrow_t const&)" );
327 DO("operator new[](unsigned long, std::nothrow_t const&)");
328 #if defined(VGO_darwin)
329 DO("malloc_zone_malloc" );
330 DO("malloc_zone_calloc" );
331 DO("malloc_zone_realloc" );
332 DO("malloc_zone_memalign" );
333 DO("malloc_zone_valloc" );
337 static void init_ignore_fns(void)
339 // Create the (empty) list.
340 ignore_fns
= VG_(newXA
)(VG_(malloc
), "ms.main.iif.1",
341 VG_(free
), sizeof(HChar
*));
344 //------------------------------------------------------------//
345 //--- Command line args ---//
346 //------------------------------------------------------------//
348 #define MAX_DEPTH 200
350 typedef enum { TimeI
, TimeMS
, TimeB
} TimeUnit
;
352 static const HChar
* TimeUnit_to_string(TimeUnit time_unit
)
355 case TimeI
: return "i";
356 case TimeMS
: return "ms";
357 case TimeB
: return "B";
358 default: tl_assert2(0, "TimeUnit_to_string: unrecognised TimeUnit");
362 static Bool clo_heap
= True
;
363 // clo_heap_admin is deliberately a word-sized type. At one point it was
364 // a UInt, but this caused problems on 64-bit machines when it was
365 // multiplied by a small negative number and then promoted to a
366 // word-sized type -- it ended up with a value of 4.2 billion. Sigh.
367 static SSizeT clo_heap_admin
= 8;
368 static Bool clo_pages_as_heap
= False
;
369 static Bool clo_stacks
= False
;
370 static Int clo_depth
= 30;
371 static double clo_threshold
= 1.0; // percentage
372 static double clo_peak_inaccuracy
= 1.0; // percentage
373 static Int clo_time_unit
= TimeI
;
374 static Int clo_detailed_freq
= 10;
375 static Int clo_max_snapshots
= 100;
376 static const HChar
* clo_massif_out_file
= "massif.out.%p";
378 static XArray
* args_for_massif
;
380 static Bool
ms_process_cmd_line_option(const HChar
* arg
)
382 const HChar
* tmp_str
;
384 // Remember the arg for later use.
385 VG_(addToXA
)(args_for_massif
, &arg
);
387 if VG_BOOL_CLO(arg
, "--heap", clo_heap
) {}
388 else if VG_BINT_CLO(arg
, "--heap-admin", clo_heap_admin
, 0, 1024) {}
390 else if VG_BOOL_CLO(arg
, "--stacks", clo_stacks
) {}
392 else if VG_BOOL_CLO(arg
, "--pages-as-heap", clo_pages_as_heap
) {}
394 else if VG_BINT_CLO(arg
, "--depth", clo_depth
, 1, MAX_DEPTH
) {}
396 else if VG_STR_CLO(arg
, "--alloc-fn", tmp_str
) {
397 VG_(addToXA
)(alloc_fns
, &tmp_str
);
399 else if VG_STR_CLO(arg
, "--ignore-fn", tmp_str
) {
400 VG_(addToXA
)(ignore_fns
, &tmp_str
);
403 else if VG_DBL_CLO(arg
, "--threshold", clo_threshold
) {
404 if (clo_threshold
< 0 || clo_threshold
> 100) {
405 VG_(fmsg_bad_option
)(arg
,
406 "--threshold must be between 0.0 and 100.0\n");
410 else if VG_DBL_CLO(arg
, "--peak-inaccuracy", clo_peak_inaccuracy
) {}
412 else if VG_XACT_CLO(arg
, "--time-unit=i", clo_time_unit
, TimeI
) {}
413 else if VG_XACT_CLO(arg
, "--time-unit=ms", clo_time_unit
, TimeMS
) {}
414 else if VG_XACT_CLO(arg
, "--time-unit=B", clo_time_unit
, TimeB
) {}
416 else if VG_BINT_CLO(arg
, "--detailed-freq", clo_detailed_freq
, 1, 1000000) {}
418 else if VG_BINT_CLO(arg
, "--max-snapshots", clo_max_snapshots
, 10, 1000) {}
420 else if VG_STR_CLO(arg
, "--massif-out-file", clo_massif_out_file
) {}
423 return VG_(replacement_malloc_process_cmd_line_option
)(arg
);
428 static void ms_print_usage(void)
431 " --heap=no|yes profile heap blocks [yes]\n"
432 " --heap-admin=<size> average admin bytes per heap block;\n"
433 " ignored if --heap=no [8]\n"
434 " --stacks=no|yes profile stack(s) [no]\n"
435 " --pages-as-heap=no|yes profile memory at the page level [no]\n"
436 " --depth=<number> depth of contexts [30]\n"
437 " --alloc-fn=<name> specify <name> as an alloc function [empty]\n"
438 " --ignore-fn=<name> ignore heap allocations within <name> [empty]\n"
439 " --threshold=<m.n> significance threshold, as a percentage [1.0]\n"
440 " --peak-inaccuracy=<m.n> maximum peak inaccuracy, as a percentage [1.0]\n"
441 " --time-unit=i|ms|B time unit: instructions executed, milliseconds\n"
442 " or heap bytes alloc'd/dealloc'd [i]\n"
443 " --detailed-freq=<N> every Nth snapshot should be detailed [10]\n"
444 " --max-snapshots=<N> maximum number of snapshots recorded [100]\n"
445 " --massif-out-file=<file> output file name [massif.out.%%p]\n"
449 static void ms_print_debug_usage(void)
457 //------------------------------------------------------------//
459 //------------------------------------------------------------//
461 // The details of the heap are represented by a single XTree.
462 // This XTree maintains the nr of allocated bytes for each
463 // stacktrace/execontext.
465 // The root of the Xtree will be output as a top node 'alloc functions',
466 // which represents all allocation functions, eg:
467 // - malloc/calloc/realloc/memalign/new/new[];
468 // - user-specified allocation functions (using --alloc-fn);
469 // - custom allocation (MALLOCLIKE) points
470 static XTree
* heap_xt
;
471 /* heap_xt contains a SizeT: the nr of allocated bytes by this execontext. */
472 static void init_szB(void* value
)
474 *((SizeT
*)value
) = 0;
476 static void add_szB(void* to
, const void* value
)
478 *((SizeT
*)to
) += *((const SizeT
*)value
);
480 static void sub_szB(void* from
, const void* value
)
482 *((SizeT
*)from
) -= *((const SizeT
*)value
);
484 static ULong
alloc_szB(const void* value
)
486 return (ULong
)*((const SizeT
*)value
);
490 //------------------------------------------------------------//
491 //--- XTree Operations ---//
492 //------------------------------------------------------------//
494 // This is the limit on the number of filtered alloc-fns that can be in a
495 // single stacktrace.
496 #define MAX_OVERESTIMATE 50
497 #define MAX_IPS (MAX_DEPTH + MAX_OVERESTIMATE)
499 // filtering out uninteresting entries:
500 // alloc-fns and entries above alloc-fns, and entries below main-or-below-main.
501 // Eg: alloc-fn1 / alloc-fn2 / a / b / main / (below main) / c
502 // becomes: a / b / main
503 // Nb: it's possible to end up with an empty trace, eg. if 'main' is marked
504 // as an alloc-fn. This is ok.
506 void filter_IPs (Addr
* ips
, Int n_ips
,
507 UInt
* top
, UInt
* n_ips_sel
)
510 Bool top_has_fnname
= False
;
516 // Advance *top as long as we find alloc functions
517 // PW Nov 2016 xtree work:
518 // old massif code was doing something really strange(?buggy):
519 // 'sliding' a bunch of functions without names by removing an
520 // alloc function 'inside' a stacktrace e.g.
521 // 0x1 0x2 0x3 alloc func1 main
522 // became 0x1 0x2 0x3 func1 main
523 for (i
= *top
; i
< n_ips
; i
++) {
524 top_has_fnname
= VG_(get_fnname
)(ips
[*top
], &fnname
);
525 if (top_has_fnname
&& VG_(strIsMemberXA
)(alloc_fns
, fnname
)) {
526 VERB(4, "filtering alloc fn %s\n", fnname
);
534 // filter the whole stacktrace if this allocation has to be ignored.
535 if (*n_ips_sel
> 0 && VG_(sizeXA
)(ignore_fns
) > 0) {
536 if (!top_has_fnname
) {
537 // top has no fnname => search for the first entry that has a fnname
538 for (i
= *top
; i
< n_ips
&& !top_has_fnname
; i
++) {
539 top_has_fnname
= VG_(get_fnname
)(ips
[i
], &fnname
);
542 if (top_has_fnname
&& VG_(strIsMemberXA
)(ignore_fns
, fnname
)) {
543 VERB(4, "ignored allocation from fn %s\n", fnname
);
549 if (!VG_(clo_show_below_main
) && *n_ips_sel
> 0 ) {
550 Int mbm
= VG_(XT_offset_main_or_below_main
)(ips
, n_ips
);
553 // Special case: the first main (or below main) function is an
556 VERB(4, "main/below main: keeping 1 fn\n");
558 *n_ips_sel
-= n_ips
- mbm
- 1;
559 VERB(4, "main/below main: filtering %d\n", n_ips
- mbm
- 1);
563 // filter the frames if we have more than clo_depth
564 if (*n_ips_sel
> clo_depth
) {
565 VERB(4, "filtering IPs above clo_depth\n");
566 *n_ips_sel
= clo_depth
;
570 // Capture a stacktrace, and make an ec of it, without the first entry
571 // if exclude_first_entry is True.
572 static ExeContext
* make_ec(ThreadId tid
, Bool exclude_first_entry
)
574 static Addr ips
[MAX_IPS
];
576 // After this call, the IPs we want are in ips[0]..ips[n_ips-1].
577 Int n_ips
= VG_(get_StackTrace
)( tid
, ips
, clo_depth
+ MAX_OVERESTIMATE
,
578 NULL
/*array to dump SP values in*/,
579 NULL
/*array to dump FP values in*/,
580 0/*first_ip_delta*/ );
581 if (exclude_first_entry
&& n_ips
> 0) {
583 VERB(4, "removing top fn %s from stacktrace\n",
584 VG_(get_fnname
)(ips
[0], &fnname
) ? fnname
: "???");
585 return VG_(make_ExeContext_from_StackTrace
)(ips
+1, n_ips
-1);
587 return VG_(make_ExeContext_from_StackTrace
)(ips
, n_ips
);
590 // Create (or update) in heap_xt an xec corresponding to the stacktrace of tid.
591 // req_szB is added to the xec (unless ec is fully filtered).
592 // Returns the correspding XTree xec.
593 // exclude_first_entry is an optimisation: if True, automatically removes
594 // the top level IP from the stacktrace. Should be set to True if it is known
595 // that this is an alloc fn. The top function presumably will be something like
596 // malloc or __builtin_new that we're sure to filter out).
597 static Xecu
add_heap_xt( ThreadId tid
, SizeT req_szB
, Bool exclude_first_entry
)
599 ExeContext
*ec
= make_ec(tid
, exclude_first_entry
);
601 if (UNLIKELY(VG_(clo_xtree_memory
) == Vg_XTMemory_Full
))
602 VG_(XTMemory_Full_alloc
)(req_szB
, ec
);
603 return VG_(XT_add_to_ec
) (heap_xt
, ec
, &req_szB
);
606 // Substract req_szB from the heap_xt where.
607 static void sub_heap_xt(Xecu where
, SizeT req_szB
, Bool exclude_first_entry
)
614 VG_(XT_sub_from_xecu
) (heap_xt
, where
, &req_szB
);
615 if (UNLIKELY(VG_(clo_xtree_memory
) == Vg_XTMemory_Full
)) {
616 ExeContext
*ec_free
= make_ec(VG_(get_running_tid
)(),
617 exclude_first_entry
);
618 VG_(XTMemory_Full_free
)(req_szB
,
619 VG_(XT_get_ec_from_xecu
)(heap_xt
, where
),
625 //------------------------------------------------------------//
626 //--- Snapshots ---//
627 //------------------------------------------------------------//
629 // Snapshots are done in a way so that we always have a reasonable number of
630 // them. We start by taking them quickly. Once we hit our limit, we cull
631 // some (eg. half), and start taking them more slowly. Once we hit the
632 // limit again, we again cull and then take them even more slowly, and so
635 #define UNUSED_SNAPSHOT_TIME -333 // A conspicuous negative number.
650 SizeT heap_extra_szB
;// Heap slop + admin bytes.
652 XTree
* xt
; // Snapshot of heap_xt, if a detailed snapshot,
656 static UInt next_snapshot_i
= 0; // Index of where next snapshot will go.
657 static Snapshot
* snapshots
; // Array of snapshots.
659 static Bool
is_snapshot_in_use(Snapshot
* snapshot
)
661 if (Unused
== snapshot
->kind
) {
662 // If snapshot is unused, check all the fields are unset.
663 tl_assert(snapshot
->time
== UNUSED_SNAPSHOT_TIME
);
664 tl_assert(snapshot
->heap_extra_szB
== 0);
665 tl_assert(snapshot
->heap_szB
== 0);
666 tl_assert(snapshot
->stacks_szB
== 0);
667 tl_assert(snapshot
->xt
== NULL
);
670 tl_assert(snapshot
->time
!= UNUSED_SNAPSHOT_TIME
);
675 static Bool
is_detailed_snapshot(Snapshot
* snapshot
)
677 return (snapshot
->xt
? True
: False
);
680 static Bool
is_uncullable_snapshot(Snapshot
* snapshot
)
682 return &snapshots
[0] == snapshot
// First snapshot
683 || &snapshots
[next_snapshot_i
-1] == snapshot
// Last snapshot
684 || snapshot
->kind
== Peak
; // Peak snapshot
687 static void sanity_check_snapshot(Snapshot
* snapshot
)
689 // Not much we can sanity check.
690 tl_assert(snapshot
->xt
== NULL
|| snapshot
->kind
!= Unused
);
693 // All the used entries should look used, all the unused ones should be clear.
694 static void sanity_check_snapshots_array(void)
697 for (i
= 0; i
< next_snapshot_i
; i
++) {
698 tl_assert( is_snapshot_in_use( & snapshots
[i
] ));
700 for ( ; i
< clo_max_snapshots
; i
++) {
701 tl_assert(!is_snapshot_in_use( & snapshots
[i
] ));
705 // This zeroes all the fields in the snapshot, but does not free the xt
706 // XTree if present. It also does a sanity check unless asked not to; we
707 // can't sanity check at startup when clearing the initial snapshots because
708 // they're full of junk.
709 static void clear_snapshot(Snapshot
* snapshot
, Bool do_sanity_check
)
711 if (do_sanity_check
) sanity_check_snapshot(snapshot
);
712 snapshot
->kind
= Unused
;
713 snapshot
->time
= UNUSED_SNAPSHOT_TIME
;
714 snapshot
->heap_extra_szB
= 0;
715 snapshot
->heap_szB
= 0;
716 snapshot
->stacks_szB
= 0;
720 // This zeroes all the fields in the snapshot, and frees the heap XTree xt if
722 static void delete_snapshot(Snapshot
* snapshot
)
724 // Nb: if there's an XTree, we free it after calling clear_snapshot,
725 // because clear_snapshot does a sanity check which includes checking the
727 XTree
* tmp_xt
= snapshot
->xt
;
728 clear_snapshot(snapshot
, /*do_sanity_check*/True
);
730 VG_(XT_delete
)(tmp_xt
);
734 static void VERB_snapshot(Int verbosity
, const HChar
* prefix
, Int i
)
736 Snapshot
* snapshot
= &snapshots
[i
];
738 switch (snapshot
->kind
) {
739 case Peak
: suffix
= "p"; break;
740 case Normal
: suffix
= ( is_detailed_snapshot(snapshot
) ? "d" : "." ); break;
741 case Unused
: suffix
= "u"; break;
743 tl_assert2(0, "VERB_snapshot: unknown snapshot kind: %d", snapshot
->kind
);
745 VERB(verbosity
, "%s S%s%3d (t:%lld, hp:%lu, ex:%lu, st:%lu)\n",
749 snapshot
->heap_extra_szB
,
754 // Cull half the snapshots; we choose those that represent the smallest
755 // time-spans, because that gives us the most even distribution of snapshots
756 // over time. (It's possible to lose interesting spikes, however.)
758 // Algorithm for N snapshots: We find the snapshot representing the smallest
759 // timeframe, and remove it. We repeat this until (N/2) snapshots are gone.
760 // We have to do this one snapshot at a time, rather than finding the (N/2)
761 // smallest snapshots in one hit, because when a snapshot is removed, its
762 // neighbours immediately cover greater timespans. So it's O(N^2), but N is
763 // small, and it's not done very often.
765 // Once we're done, we return the new smallest interval between snapshots.
766 // That becomes our minimum time interval.
767 static UInt
cull_snapshots(void)
769 Int i
, jp
, j
, jn
, min_timespan_i
;
775 // Sets j to the index of the first not-yet-removed snapshot at or after i
776 #define FIND_SNAPSHOT(i, j) \
778 j < clo_max_snapshots && !is_snapshot_in_use(&snapshots[j]); \
781 VERB(2, "Culling...\n");
783 // First we remove enough snapshots by clearing them in-place. Once
784 // that's done, we can slide the remaining ones down.
785 for (i
= 0; i
< clo_max_snapshots
/2; i
++) {
786 // Find the snapshot representing the smallest timespan. The timespan
787 // for snapshot n = d(N-1,N)+d(N,N+1), where d(A,B) is the time between
788 // snapshot A and B. We don't consider the first and last snapshots for
790 Snapshot
* min_snapshot
;
793 // Initial triple: (prev, curr, next) == (jp, j, jn)
794 // Initial min_timespan is the first one.
797 FIND_SNAPSHOT(j
+1, jn
);
798 min_timespan
= 0x7fffffffffffffffLL
;
800 while (jn
< clo_max_snapshots
) {
801 Time timespan
= snapshots
[jn
].time
- snapshots
[jp
].time
;
802 tl_assert(timespan
>= 0);
803 // Nb: We never cull the peak snapshot.
804 if (Peak
!= snapshots
[j
].kind
&& timespan
< min_timespan
) {
805 min_timespan
= timespan
;
808 // Move on to next triple
811 FIND_SNAPSHOT(jn
+1, jn
);
813 // We've found the least important snapshot, now delete it. First
814 // print it if necessary.
815 tl_assert(-1 != min_j
); // Check we found a minimum.
816 min_snapshot
= & snapshots
[ min_j
];
817 if (VG_(clo_verbosity
) > 1) {
818 HChar buf
[64]; // large enough
819 VG_(snprintf
)(buf
, 64, " %3d (t-span = %lld)", i
, min_timespan
);
820 VERB_snapshot(2, buf
, min_j
);
822 delete_snapshot(min_snapshot
);
826 // Slide down the remaining snapshots over the removed ones. First set i
827 // to point to the first empty slot, and j to the first full slot after
828 // i. Then slide everything down.
829 for (i
= 0; is_snapshot_in_use( &snapshots
[i
] ); i
++) { }
830 for (j
= i
; !is_snapshot_in_use( &snapshots
[j
] ); j
++) { }
831 for ( ; j
< clo_max_snapshots
; j
++) {
832 if (is_snapshot_in_use( &snapshots
[j
] )) {
833 snapshots
[i
++] = snapshots
[j
];
834 clear_snapshot(&snapshots
[j
], /*do_sanity_check*/True
);
839 // Check snapshots array looks ok after changes.
840 sanity_check_snapshots_array();
842 // Find the minimum timespan remaining; that will be our new minimum
843 // time interval. Note that above we were finding timespans by measuring
844 // two intervals around a snapshot that was under consideration for
845 // deletion. Here we only measure single intervals because all the
846 // deletions have occurred.
848 // But we have to be careful -- some snapshots (eg. snapshot 0, and the
849 // peak snapshot) are uncullable. If two uncullable snapshots end up
850 // next to each other, they'll never be culled (assuming the peak doesn't
851 // change), and the time gap between them will not change. However, the
852 // time between the remaining cullable snapshots will grow ever larger.
853 // This means that the min_timespan found will always be that between the
854 // two uncullable snapshots, and it will be much smaller than it should
855 // be. To avoid this problem, when computing the minimum timespan, we
856 // ignore any timespans between two uncullable snapshots.
857 tl_assert(next_snapshot_i
> 1);
858 min_timespan
= 0x7fffffffffffffffLL
;
860 for (i
= 1; i
< next_snapshot_i
; i
++) {
861 if (is_uncullable_snapshot(&snapshots
[i
]) &&
862 is_uncullable_snapshot(&snapshots
[i
-1]))
864 VERB(2, "(Ignoring interval %d--%d when computing minimum)\n", i
-1, i
);
866 Time timespan
= snapshots
[i
].time
- snapshots
[i
-1].time
;
867 tl_assert(timespan
>= 0);
868 if (timespan
< min_timespan
) {
869 min_timespan
= timespan
;
874 tl_assert(-1 != min_timespan_i
); // Check we found a minimum.
876 // Print remaining snapshots, if necessary.
877 if (VG_(clo_verbosity
) > 1) {
878 VERB(2, "Finished culling (%3d of %3d deleted)\n",
879 n_deleted
, clo_max_snapshots
);
880 for (i
= 0; i
< next_snapshot_i
; i
++) {
881 VERB_snapshot(2, " post-cull", i
);
883 VERB(2, "New time interval = %lld (between snapshots %d and %d)\n",
884 min_timespan
, min_timespan_i
-1, min_timespan_i
);
890 static Time
get_time(void)
892 // Get current time, in whatever time unit we're using.
893 if (clo_time_unit
== TimeI
) {
894 return guest_instrs_executed
;
895 } else if (clo_time_unit
== TimeMS
) {
896 // Some stuff happens between the millisecond timer being initialised
897 // to zero and us taking our first snapshot. We determine that time
898 // gap so we can subtract it from all subsequent times so that our
899 // first snapshot is considered to be at t = 0ms. Unfortunately, a
900 // bunch of symbols get read after the first snapshot is taken but
901 // before the second one (which is triggered by the first allocation),
902 // so when the time-unit is 'ms' we always have a big gap between the
903 // first two snapshots. But at least users won't have to wonder why
904 // the first snapshot isn't at t=0.
905 static Bool is_first_get_time
= True
;
906 static Time start_time_ms
;
907 if (is_first_get_time
) {
908 start_time_ms
= VG_(read_millisecond_timer
)();
909 is_first_get_time
= False
;
912 return VG_(read_millisecond_timer
)() - start_time_ms
;
914 } else if (clo_time_unit
== TimeB
) {
915 return total_allocs_deallocs_szB
;
917 tl_assert2(0, "bad --time-unit value");
921 // Take a snapshot, and only that -- decisions on whether to take a
922 // snapshot, or what kind of snapshot, are made elsewhere.
923 // Nb: we call the arg "my_time" because "time" shadows a global declaration
924 // in /usr/include/time.h on Darwin.
926 take_snapshot(Snapshot
* snapshot
, SnapshotKind kind
, Time my_time
,
929 tl_assert(!is_snapshot_in_use(snapshot
));
930 if (!clo_pages_as_heap
) {
931 tl_assert(have_started_executing_code
);
934 // Heap and heap admin.
936 snapshot
->heap_szB
= heap_szB
;
938 snapshot
->xt
= VG_(XT_snapshot
)(heap_xt
);
940 snapshot
->heap_extra_szB
= heap_extra_szB
;
945 snapshot
->stacks_szB
= stacks_szB
;
949 snapshot
->kind
= kind
;
950 snapshot
->time
= my_time
;
951 sanity_check_snapshot(snapshot
);
954 if (Peak
== kind
) n_peak_snapshots
++;
955 if (is_detailed
) n_detailed_snapshots
++;
960 // Take a snapshot, if it's time, or if we've hit a peak.
962 maybe_take_snapshot(SnapshotKind kind
, const HChar
* what
)
964 // 'min_time_interval' is the minimum time interval between snapshots.
965 // If we try to take a snapshot and less than this much time has passed,
966 // we don't take it. It gets larger as the program runs longer. It's
967 // initialised to zero so that we begin by taking snapshots as quickly as
969 static Time min_time_interval
= 0;
970 // Zero allows startup snapshot.
971 static Time earliest_possible_time_of_next_snapshot
= 0;
972 static Int n_snapshots_since_last_detailed
= 0;
973 static Int n_skipped_snapshots_since_last_snapshot
= 0;
977 // Nb: we call this variable "my_time" because "time" shadows a global
978 // declaration in /usr/include/time.h on Darwin.
979 Time my_time
= get_time();
983 // Only do a snapshot if it's time.
984 if (my_time
< earliest_possible_time_of_next_snapshot
) {
985 n_skipped_snapshots
++;
986 n_skipped_snapshots_since_last_snapshot
++;
989 is_detailed
= (clo_detailed_freq
-1 == n_snapshots_since_last_detailed
);
993 // Because we're about to do a deallocation, we're coming down from a
994 // local peak. If it is (a) actually a global peak, and (b) a certain
995 // amount bigger than the previous peak, then we take a peak snapshot.
996 // By not taking a snapshot for every peak, we save a lot of effort --
997 // because many peaks remain peak only for a short time.
998 SizeT total_szB
= heap_szB
+ heap_extra_szB
+ stacks_szB
;
999 SizeT excess_szB_for_new_peak
=
1000 (SizeT
)((peak_snapshot_total_szB
* clo_peak_inaccuracy
) / 100);
1001 if (total_szB
<= peak_snapshot_total_szB
+ excess_szB_for_new_peak
) {
1009 tl_assert2(0, "maybe_take_snapshot: unrecognised snapshot kind");
1012 // Take the snapshot.
1013 snapshot
= & snapshots
[next_snapshot_i
];
1014 take_snapshot(snapshot
, kind
, my_time
, is_detailed
);
1016 // Record if it was detailed.
1018 n_snapshots_since_last_detailed
= 0;
1020 n_snapshots_since_last_detailed
++;
1023 // Update peak data, if it's a Peak snapshot.
1025 Int i
, number_of_peaks_snapshots_found
= 0;
1027 // Sanity check the size, then update our recorded peak.
1028 SizeT snapshot_total_szB
=
1029 snapshot
->heap_szB
+ snapshot
->heap_extra_szB
+ snapshot
->stacks_szB
;
1030 tl_assert2(snapshot_total_szB
> peak_snapshot_total_szB
,
1031 "%ld, %ld\n", snapshot_total_szB
, peak_snapshot_total_szB
);
1032 peak_snapshot_total_szB
= snapshot_total_szB
;
1034 // Find the old peak snapshot, if it exists, and mark it as normal.
1035 for (i
= 0; i
< next_snapshot_i
; i
++) {
1036 if (Peak
== snapshots
[i
].kind
) {
1037 snapshots
[i
].kind
= Normal
;
1038 number_of_peaks_snapshots_found
++;
1041 tl_assert(number_of_peaks_snapshots_found
<= 1);
1044 // Finish up verbosity and stats stuff.
1045 if (n_skipped_snapshots_since_last_snapshot
> 0) {
1046 VERB(2, " (skipped %d snapshot%s)\n",
1047 n_skipped_snapshots_since_last_snapshot
,
1048 ( 1 == n_skipped_snapshots_since_last_snapshot
? "" : "s") );
1050 VERB_snapshot(2, what
, next_snapshot_i
);
1051 n_skipped_snapshots_since_last_snapshot
= 0;
1053 // Cull the entries, if our snapshot table is full.
1055 if (clo_max_snapshots
== next_snapshot_i
) {
1056 min_time_interval
= cull_snapshots();
1059 // Work out the earliest time when the next snapshot can happen.
1060 earliest_possible_time_of_next_snapshot
= my_time
+ min_time_interval
;
1064 //------------------------------------------------------------//
1065 //--- Sanity checking ---//
1066 //------------------------------------------------------------//
1068 static Bool
ms_cheap_sanity_check ( void )
1070 return True
; // Nothing useful we can cheaply check.
1073 static Bool
ms_expensive_sanity_check ( void )
1076 sanity_check_snapshots_array();
1081 //------------------------------------------------------------//
1082 //--- Heap management ---//
1083 //------------------------------------------------------------//
1085 // Metadata for heap blocks. Each one contains an Xecu,
1086 // which identifies the XTree ec at which it was allocated. From
1087 // HP_Chunks, XTree ec 'space' field is incremented (at allocation) and
1088 // decremented (at deallocation).
1090 // Nb: first two fields must match core's VgHashNode.
1093 struct _HP_Chunk
* next
;
1094 Addr data
; // Ptr to actual block
1095 SizeT req_szB
; // Size requested
1096 SizeT slop_szB
; // Extra bytes given above those requested
1097 Xecu where
; // Where allocated; XTree xecu from heap_xt
1101 /* Pool allocator for HP_Chunk. */
1102 static PoolAlloc
*HP_chunk_poolalloc
= NULL
;
1104 static VgHashTable
*malloc_list
= NULL
; // HP_Chunks
1106 static void update_alloc_stats(SSizeT szB_delta
)
1108 // Update total_allocs_deallocs_szB.
1109 if (szB_delta
< 0) szB_delta
= -szB_delta
;
1110 total_allocs_deallocs_szB
+= szB_delta
;
1113 static void update_heap_stats(SSizeT heap_szB_delta
, Int heap_extra_szB_delta
)
1115 if (heap_szB_delta
< 0)
1116 tl_assert(heap_szB
>= -heap_szB_delta
);
1117 if (heap_extra_szB_delta
< 0)
1118 tl_assert(heap_extra_szB
>= -heap_extra_szB_delta
);
1120 heap_extra_szB
+= heap_extra_szB_delta
;
1121 heap_szB
+= heap_szB_delta
;
1123 update_alloc_stats(heap_szB_delta
+ heap_extra_szB_delta
);
1127 void* record_block( ThreadId tid
, void* p
, SizeT req_szB
, SizeT slop_szB
,
1128 Bool exclude_first_entry
, Bool maybe_snapshot
)
1130 // Make new HP_Chunk node, add to malloc_list
1131 HP_Chunk
* hc
= VG_(allocEltPA
)(HP_chunk_poolalloc
);
1132 hc
->req_szB
= req_szB
;
1133 hc
->slop_szB
= slop_szB
;
1136 VG_(HT_add_node
)(malloc_list
, hc
);
1139 VERB(3, "<<< record_block (%lu, %lu)\n", req_szB
, slop_szB
);
1141 hc
->where
= add_heap_xt( tid
, req_szB
, exclude_first_entry
);
1143 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1144 // Update statistics.
1147 // Update heap stats.
1148 update_heap_stats(req_szB
, clo_heap_admin
+ slop_szB
);
1150 // Maybe take a snapshot.
1151 if (maybe_snapshot
) {
1152 maybe_take_snapshot(Normal
, " alloc");
1156 // Ignored allocation.
1157 n_ignored_heap_allocs
++;
1159 VERB(3, "(ignored)\n");
1169 void* alloc_and_record_block ( ThreadId tid
, SizeT req_szB
, SizeT req_alignB
,
1172 SizeT actual_szB
, slop_szB
;
1175 if ((SSizeT
)req_szB
< 0) return NULL
;
1177 // Allocate and zero if necessary.
1178 p
= VG_(cli_malloc
)( req_alignB
, req_szB
);
1182 if (is_zeroed
) VG_(memset
)(p
, 0, req_szB
);
1183 actual_szB
= VG_(cli_malloc_usable_size
)(p
);
1184 tl_assert(actual_szB
>= req_szB
);
1185 slop_szB
= actual_szB
- req_szB
;
1188 record_block(tid
, p
, req_szB
, slop_szB
, /*exclude_first_entry*/True
,
1189 /*maybe_snapshot*/True
);
1195 void unrecord_block ( void* p
, Bool maybe_snapshot
, Bool exclude_first_entry
)
1197 // Remove HP_Chunk from malloc_list
1198 HP_Chunk
* hc
= VG_(HT_remove
)(malloc_list
, (UWord
)p
);
1200 return; // must have been a bogus free()
1204 VERB(3, "<<< unrecord_block\n");
1206 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1207 // Update statistics.
1210 // Maybe take a peak snapshot, since it's a deallocation.
1211 if (maybe_snapshot
) {
1212 maybe_take_snapshot(Peak
, "de-PEAK");
1215 // Update heap stats.
1216 update_heap_stats(-hc
->req_szB
, -clo_heap_admin
- hc
->slop_szB
);
1219 sub_heap_xt(hc
->where
, hc
->req_szB
, exclude_first_entry
);
1221 // Maybe take a snapshot.
1222 if (maybe_snapshot
) {
1223 maybe_take_snapshot(Normal
, "dealloc");
1227 n_ignored_heap_frees
++;
1229 VERB(3, "(ignored)\n");
1232 VERB(3, ">>> (-%lu, -%lu)\n", hc
->req_szB
, hc
->slop_szB
);
1235 // Actually free the chunk, and the heap block (if necessary)
1236 VG_(freeEltPA
) (HP_chunk_poolalloc
, hc
); hc
= NULL
;
1239 // Nb: --ignore-fn is tricky for realloc. If the block's original alloc was
1240 // ignored, but the realloc is not requested to be ignored, and we are
1241 // shrinking the block, then we have to ignore the realloc -- otherwise we
1242 // could end up with negative heap sizes. This isn't a danger if we are
1243 // growing such a block, but for consistency (it also simplifies things) we
1244 // ignore such reallocs as well.
1245 // PW Nov 2016 xtree work: why can't we just consider that a realloc of an
1246 // ignored alloc is just a new alloc (i.e. do not remove the old sz from the
1247 // stats). Then everything would be fine, and a non ignored realloc would be
1248 // counted properly.
1250 void* realloc_block ( ThreadId tid
, void* p_old
, SizeT new_req_szB
)
1254 SizeT old_req_szB
, old_slop_szB
, new_slop_szB
, new_actual_szB
;
1256 Bool is_ignored
= False
;
1258 // Remove the old block
1259 hc
= VG_(HT_remove
)(malloc_list
, (UWord
)p_old
);
1261 return NULL
; // must have been a bogus realloc()
1264 old_req_szB
= hc
->req_szB
;
1265 old_slop_szB
= hc
->slop_szB
;
1267 tl_assert(!clo_pages_as_heap
); // Shouldn't be here if --pages-as-heap=yes.
1269 VERB(3, "<<< realloc_block (%lu)\n", new_req_szB
);
1271 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1272 // Update statistics.
1275 // Maybe take a peak snapshot, if it's (effectively) a deallocation.
1276 if (new_req_szB
< old_req_szB
) {
1277 maybe_take_snapshot(Peak
, "re-PEAK");
1280 // The original malloc was ignored, so we have to ignore the
1286 // Actually do the allocation, if necessary.
1287 if (new_req_szB
<= old_req_szB
+ old_slop_szB
) {
1288 // New size is smaller or same; block not moved.
1290 new_slop_szB
= old_slop_szB
+ (old_req_szB
- new_req_szB
);
1293 // New size is bigger; make new block, copy shared contents, free old.
1294 p_new
= VG_(cli_malloc
)(VG_(clo_alignment
), new_req_szB
);
1296 // Nb: if realloc fails, NULL is returned but the old block is not
1297 // touched. What an awful function.
1300 VG_(memcpy
)(p_new
, p_old
, old_req_szB
+ old_slop_szB
);
1301 VG_(cli_free
)(p_old
);
1302 new_actual_szB
= VG_(cli_malloc_usable_size
)(p_new
);
1303 tl_assert(new_actual_szB
>= new_req_szB
);
1304 new_slop_szB
= new_actual_szB
- new_req_szB
;
1309 hc
->data
= (Addr
)p_new
;
1310 hc
->req_szB
= new_req_szB
;
1311 hc
->slop_szB
= new_slop_szB
;
1312 old_where
= hc
->where
;
1317 hc
->where
= add_heap_xt( tid
, new_req_szB
,
1318 /*exclude_first_entry*/True
);
1319 if (!is_ignored
&& VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1320 sub_heap_xt(old_where
, old_req_szB
, /*exclude_first_entry*/True
);
1322 // The realloc itself is ignored.
1325 /* XTREE??? hack to have something compatible with pre
1326 m_xtree massif: if the previous alloc/realloc was
1327 ignored, and this one is not ignored, then keep the
1328 previous where, to continue marking this memory as
1330 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0
1331 && VG_(XT_n_ips_sel
)(heap_xt
, old_where
) == 0)
1332 hc
->where
= old_where
;
1334 // Update statistics.
1335 n_ignored_heap_reallocs
++;
1340 // Now insert the new hc (with a possibly new 'data' field) into
1341 // malloc_list. If this realloc() did not increase the memory size, we
1342 // will have removed and then re-added hc unnecessarily. But that's ok
1343 // because shrinking a block with realloc() is (presumably) much rarer
1344 // than growing it, and this way simplifies the growing case.
1345 VG_(HT_add_node
)(malloc_list
, hc
);
1349 // Update heap stats.
1350 update_heap_stats(new_req_szB
- old_req_szB
,
1351 new_slop_szB
- old_slop_szB
);
1353 // Maybe take a snapshot.
1354 maybe_take_snapshot(Normal
, "realloc");
1357 VERB(3, "(ignored)\n");
1360 VERB(3, ">>> (%ld, %ld)\n",
1361 (SSizeT
)(new_req_szB
- old_req_szB
),
1362 (SSizeT
)(new_slop_szB
- old_slop_szB
));
1369 //------------------------------------------------------------//
1370 //--- malloc() et al replacement wrappers ---//
1371 //------------------------------------------------------------//
1373 static void* ms_malloc ( ThreadId tid
, SizeT szB
)
1375 return alloc_and_record_block( tid
, szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1378 static void* ms___builtin_new ( ThreadId tid
, SizeT szB
)
1380 return alloc_and_record_block( tid
, szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1383 static void* ms___builtin_vec_new ( ThreadId tid
, SizeT szB
)
1385 return alloc_and_record_block( tid
, szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1388 static void* ms_calloc ( ThreadId tid
, SizeT m
, SizeT szB
)
1390 return alloc_and_record_block( tid
, m
*szB
, VG_(clo_alignment
), /*is_zeroed*/True
);
1393 static void *ms_memalign ( ThreadId tid
, SizeT alignB
, SizeT szB
)
1395 return alloc_and_record_block( tid
, szB
, alignB
, False
);
1398 static void ms_free ( ThreadId tid
__attribute__((unused
)), void* p
)
1400 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1404 static void ms___builtin_delete ( ThreadId tid
, void* p
)
1406 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1410 static void ms___builtin_vec_delete ( ThreadId tid
, void* p
)
1412 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1416 static void* ms_realloc ( ThreadId tid
, void* p_old
, SizeT new_szB
)
1418 return realloc_block(tid
, p_old
, new_szB
);
1421 static SizeT
ms_malloc_usable_size ( ThreadId tid
, void* p
)
1423 HP_Chunk
* hc
= VG_(HT_lookup
)( malloc_list
, (UWord
)p
);
1425 return ( hc
? hc
->req_szB
+ hc
->slop_szB
: 0 );
1428 //------------------------------------------------------------//
1429 //--- Page handling ---//
1430 //------------------------------------------------------------//
1433 void ms_record_page_mem ( Addr a
, SizeT len
)
1435 ThreadId tid
= VG_(get_running_tid
)();
1437 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1438 tl_assert(len
>= VKI_PAGE_SIZE
);
1439 // Record the first N-1 pages as blocks, but don't do any snapshots.
1440 for (end
= a
+ len
- VKI_PAGE_SIZE
; a
< end
; a
+= VKI_PAGE_SIZE
) {
1441 record_block( tid
, (void*)a
, VKI_PAGE_SIZE
, /*slop_szB*/0,
1442 /*exclude_first_entry*/False
, /*maybe_snapshot*/False
);
1444 // Record the last page as a block, and maybe do a snapshot afterwards.
1445 record_block( tid
, (void*)a
, VKI_PAGE_SIZE
, /*slop_szB*/0,
1446 /*exclude_first_entry*/False
, /*maybe_snapshot*/True
);
1450 void ms_unrecord_page_mem( Addr a
, SizeT len
)
1453 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1454 tl_assert(len
>= VKI_PAGE_SIZE
);
1455 // Unrecord the first page. This might be the peak, so do a snapshot.
1456 unrecord_block((void*)a
, /*maybe_snapshot*/True
,
1457 /*exclude_first_entry*/False
);
1459 // Then unrecord the remaining pages, but without snapshots.
1460 for (end
= a
+ len
- VKI_PAGE_SIZE
; a
< end
; a
+= VKI_PAGE_SIZE
) {
1461 unrecord_block((void*)a
, /*maybe_snapshot*/False
,
1462 /*exclude_first_entry*/False
);
1466 //------------------------------------------------------------//
1469 void ms_new_mem_mmap ( Addr a
, SizeT len
,
1470 Bool rr
, Bool ww
, Bool xx
, ULong di_handle
)
1472 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1473 ms_record_page_mem(a
, len
);
1477 void ms_new_mem_startup( Addr a
, SizeT len
,
1478 Bool rr
, Bool ww
, Bool xx
, ULong di_handle
)
1480 // startup maps are always be page-sized, except the trampoline page is
1481 // marked by the core as only being the size of the trampoline itself,
1482 // which is something like 57 bytes. Round it up to page size.
1483 len
= VG_PGROUNDUP(len
);
1484 ms_record_page_mem(a
, len
);
1488 void ms_new_mem_brk ( Addr a
, SizeT len
, ThreadId tid
)
1490 // brk limit is not necessarily aligned on a page boundary.
1491 // If new memory being brk-ed implies to allocate a new page,
1492 // then call ms_record_page_mem with page aligned parameters
1493 // otherwise just ignore.
1494 Addr old_bottom_page
= VG_PGROUNDDN(a
- 1);
1495 Addr new_top_page
= VG_PGROUNDDN(a
+ len
- 1);
1496 if (old_bottom_page
!= new_top_page
)
1497 ms_record_page_mem(VG_PGROUNDDN(a
),
1498 (new_top_page
- old_bottom_page
));
1502 void ms_copy_mem_remap( Addr from
, Addr to
, SizeT len
)
1504 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1505 ms_unrecord_page_mem(from
, len
);
1506 ms_record_page_mem(to
, len
);
1510 void ms_die_mem_munmap( Addr a
, SizeT len
)
1512 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1513 ms_unrecord_page_mem(a
, len
);
1517 void ms_die_mem_brk( Addr a
, SizeT len
)
1519 // Call ms_unrecord_page_mem only if one or more pages are de-allocated.
1520 // See ms_new_mem_brk for more details.
1521 Addr new_bottom_page
= VG_PGROUNDDN(a
- 1);
1522 Addr old_top_page
= VG_PGROUNDDN(a
+ len
- 1);
1523 if (old_top_page
!= new_bottom_page
)
1524 ms_unrecord_page_mem(VG_PGROUNDDN(a
),
1525 (old_top_page
- new_bottom_page
));
1529 //------------------------------------------------------------//
1531 //------------------------------------------------------------//
1533 // We really want the inlining to occur...
1534 #define INLINE inline __attribute__((always_inline))
1536 static void update_stack_stats(SSizeT stack_szB_delta
)
1538 if (stack_szB_delta
< 0) tl_assert(stacks_szB
>= -stack_szB_delta
);
1539 stacks_szB
+= stack_szB_delta
;
1541 update_alloc_stats(stack_szB_delta
);
1544 static INLINE
void new_mem_stack_2(SizeT len
, const HChar
* what
)
1546 if (have_started_executing_code
) {
1547 VERB(3, "<<< new_mem_stack (%lu)\n", len
);
1549 update_stack_stats(len
);
1550 maybe_take_snapshot(Normal
, what
);
1555 static INLINE
void die_mem_stack_2(SizeT len
, const HChar
* what
)
1557 if (have_started_executing_code
) {
1558 VERB(3, "<<< die_mem_stack (-%lu)\n", len
);
1560 maybe_take_snapshot(Peak
, "stkPEAK");
1561 update_stack_stats(-len
);
1562 maybe_take_snapshot(Normal
, what
);
1567 static void new_mem_stack(Addr a
, SizeT len
)
1569 new_mem_stack_2(len
, "stk-new");
1572 static void die_mem_stack(Addr a
, SizeT len
)
1574 die_mem_stack_2(len
, "stk-die");
1577 static void new_mem_stack_signal(Addr a
, SizeT len
, ThreadId tid
)
1579 new_mem_stack_2(len
, "sig-new");
1582 static void die_mem_stack_signal(Addr a
, SizeT len
)
1584 die_mem_stack_2(len
, "sig-die");
1588 //------------------------------------------------------------//
1589 //--- Client Requests ---//
1590 //------------------------------------------------------------//
1592 static void print_monitor_help ( void )
1596 "massif monitor commands:\n"
1597 " snapshot [<filename>]\n"
1598 " detailed_snapshot [<filename>]\n"
1599 " takes a snapshot (or a detailed snapshot)\n"
1600 " and saves it in <filename>\n"
1601 " default <filename> is massif.vgdb.out\n"
1602 " all_snapshots [<filename>]\n"
1603 " saves all snapshot(s) taken so far in <filename>\n"
1604 " default <filename> is massif.vgdb.out\n"
1605 " xtmemory [<filename>]\n"
1606 " dump xtree memory profile in <filename> (default xtmemory.kcg.%%p.%%n)\n"
1611 /* Forward declaration.
1612 return True if request recognised, False otherwise */
1613 static Bool
handle_gdb_monitor_command (ThreadId tid
, HChar
*req
);
1614 static Bool
ms_handle_client_request ( ThreadId tid
, UWord
* argv
, UWord
* ret
)
1617 case VG_USERREQ__MALLOCLIKE_BLOCK
: {
1618 void* p
= (void*)argv
[1];
1619 SizeT szB
= argv
[2];
1620 record_block( tid
, p
, szB
, /*slop_szB*/0, /*exclude_first_entry*/False
,
1621 /*maybe_snapshot*/True
);
1625 case VG_USERREQ__RESIZEINPLACE_BLOCK
: {
1626 void* p
= (void*)argv
[1];
1627 SizeT newSizeB
= argv
[3];
1629 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/False
);
1630 record_block(tid
, p
, newSizeB
, /*slop_szB*/0,
1631 /*exclude_first_entry*/False
, /*maybe_snapshot*/True
);
1634 case VG_USERREQ__FREELIKE_BLOCK
: {
1635 void* p
= (void*)argv
[1];
1636 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/False
);
1640 case VG_USERREQ__GDB_MONITOR_COMMAND
: {
1641 Bool handled
= handle_gdb_monitor_command (tid
, (HChar
*)argv
[1]);
1655 //------------------------------------------------------------//
1656 //--- Instrumentation ---//
1657 //------------------------------------------------------------//
1659 static void add_counter_update(IRSB
* sbOut
, Int n
)
1661 #if defined(VG_BIGENDIAN)
1662 # define END Iend_BE
1663 #elif defined(VG_LITTLEENDIAN)
1664 # define END Iend_LE
1666 # error "Unknown endianness"
1668 // Add code to increment 'guest_instrs_executed' by 'n', like this:
1669 // WrTmp(t1, Load64(&guest_instrs_executed))
1670 // WrTmp(t2, Add64(RdTmp(t1), Const(n)))
1671 // Store(&guest_instrs_executed, t2)
1672 IRTemp t1
= newIRTemp(sbOut
->tyenv
, Ity_I64
);
1673 IRTemp t2
= newIRTemp(sbOut
->tyenv
, Ity_I64
);
1674 IRExpr
* counter_addr
= mkIRExpr_HWord( (HWord
)&guest_instrs_executed
);
1676 IRStmt
* st1
= IRStmt_WrTmp(t1
, IRExpr_Load(END
, Ity_I64
, counter_addr
));
1679 IRExpr_Binop(Iop_Add64
, IRExpr_RdTmp(t1
),
1680 IRExpr_Const(IRConst_U64(n
))));
1681 IRStmt
* st3
= IRStmt_Store(END
, counter_addr
, IRExpr_RdTmp(t2
));
1683 addStmtToIRSB( sbOut
, st1
);
1684 addStmtToIRSB( sbOut
, st2
);
1685 addStmtToIRSB( sbOut
, st3
);
1688 static IRSB
* ms_instrument2( IRSB
* sbIn
)
1693 // We increment the instruction count in two places:
1694 // - just before any Ist_Exit statements;
1695 // - just before the IRSB's end.
1696 // In the former case, we zero 'n' and then continue instrumenting.
1698 sbOut
= deepCopyIRSBExceptStmts(sbIn
);
1700 for (i
= 0; i
< sbIn
->stmts_used
; i
++) {
1701 IRStmt
* st
= sbIn
->stmts
[i
];
1703 if (!st
|| st
->tag
== Ist_NoOp
) continue;
1705 if (st
->tag
== Ist_IMark
) {
1707 } else if (st
->tag
== Ist_Exit
) {
1709 // Add an increment before the Exit statement, then reset 'n'.
1710 add_counter_update(sbOut
, n
);
1714 addStmtToIRSB( sbOut
, st
);
1718 // Add an increment before the SB end.
1719 add_counter_update(sbOut
, n
);
1725 IRSB
* ms_instrument ( VgCallbackClosure
* closure
,
1727 const VexGuestLayout
* layout
,
1728 const VexGuestExtents
* vge
,
1729 const VexArchInfo
* archinfo_host
,
1730 IRType gWordTy
, IRType hWordTy
)
1732 if (! have_started_executing_code
) {
1733 // Do an initial sample to guarantee that we have at least one.
1734 // We use 'maybe_take_snapshot' instead of 'take_snapshot' to ensure
1735 // 'maybe_take_snapshot's internal static variables are initialised.
1736 have_started_executing_code
= True
;
1737 maybe_take_snapshot(Normal
, "startup");
1740 if (clo_time_unit
== TimeI
) { return ms_instrument2(sbIn
); }
1741 else if (clo_time_unit
== TimeMS
) { return sbIn
; }
1742 else if (clo_time_unit
== TimeB
) { return sbIn
; }
1743 else { tl_assert2(0, "bad --time-unit value"); }
1747 //------------------------------------------------------------//
1748 //--- Writing snapshots ---//
1749 //------------------------------------------------------------//
1751 static void pp_snapshot(MsFile
*fp
, Snapshot
* snapshot
, Int snapshot_n
)
1753 const Massif_Header header
= (Massif_Header
) {
1754 .snapshot_n
= snapshot_n
,
1755 .time
= snapshot
->time
,
1756 .sz_B
= snapshot
->heap_szB
,
1757 .extra_B
= snapshot
->heap_extra_szB
,
1758 .stacks_B
= snapshot
->stacks_szB
,
1759 .detailed
= is_detailed_snapshot(snapshot
),
1760 .peak
= Peak
== snapshot
->kind
,
1761 .top_node_desc
= clo_pages_as_heap
?
1762 "(page allocation syscalls) mmap/mremap/brk, --alloc-fns, etc."
1763 : "(heap allocation functions) malloc/new/new[], --alloc-fns, etc.",
1764 .sig_threshold
= clo_threshold
1767 sanity_check_snapshot(snapshot
);
1769 VG_(XT_massif_print
)(fp
, snapshot
->xt
, &header
, alloc_szB
);
1772 static void write_snapshots_to_file(const HChar
* massif_out_file
,
1773 Snapshot snapshots_array
[],
1779 fp
= VG_(XT_massif_open
)(massif_out_file
,
1782 TimeUnit_to_string(clo_time_unit
));
1784 return; // Error reported by VG_(XT_massif_open)
1786 for (i
= 0; i
< nr_elements
; i
++) {
1787 Snapshot
* snapshot
= & snapshots_array
[i
];
1788 pp_snapshot(fp
, snapshot
, i
); // Detailed snapshot!
1790 VG_(XT_massif_close
) (fp
);
1793 static void write_snapshots_array_to_file(void)
1795 // Setup output filename. Nb: it's important to do this now, ie. as late
1796 // as possible. If we do it at start-up and the program forks and the
1797 // output file format string contains a %p (pid) specifier, both the
1798 // parent and child will incorrectly write to the same file; this
1799 // happened in 3.3.0.
1800 HChar
* massif_out_file
=
1801 VG_(expand_file_name
)("--massif-out-file", clo_massif_out_file
);
1802 write_snapshots_to_file (massif_out_file
, snapshots
, next_snapshot_i
);
1803 VG_(free
)(massif_out_file
);
1806 static void handle_snapshot_monitor_command (const HChar
*filename
,
1811 if (!clo_pages_as_heap
&& !have_started_executing_code
) {
1812 // See comments of variable have_started_executing_code.
1814 ("error: cannot take snapshot before execution has started\n");
1818 clear_snapshot(&snapshot
, /* do_sanity_check */ False
);
1819 take_snapshot(&snapshot
, Normal
, get_time(), detailed
);
1820 write_snapshots_to_file ((filename
== NULL
) ?
1821 "massif.vgdb.out" : filename
,
1824 delete_snapshot(&snapshot
);
1827 static void handle_all_snapshots_monitor_command (const HChar
*filename
)
1829 if (!clo_pages_as_heap
&& !have_started_executing_code
) {
1830 // See comments of variable have_started_executing_code.
1832 ("error: cannot take snapshot before execution has started\n");
1836 write_snapshots_to_file ((filename
== NULL
) ?
1837 "massif.vgdb.out" : filename
,
1838 snapshots
, next_snapshot_i
);
1841 static void xtmemory_report_next_block(XT_Allocs
* xta
, ExeContext
** ec_alloc
)
1843 const HP_Chunk
* hc
= VG_(HT_Next
)(malloc_list
);
1845 xta
->nbytes
= hc
->req_szB
;
1847 *ec_alloc
= VG_(XT_get_ec_from_xecu
)(heap_xt
, hc
->where
);
1851 static void ms_xtmemory_report ( const HChar
* filename
, Bool fini
)
1853 // Make xtmemory_report_next_block ready to be called.
1854 VG_(HT_ResetIter
)(malloc_list
);
1855 VG_(XTMemory_report
)(filename
, fini
, xtmemory_report_next_block
,
1856 VG_(XT_filter_maybe_below_main
));
1857 /* As massif already filters one top function, use as filter
1858 VG_(XT_filter_maybe_below_main). */
1861 static Bool
handle_gdb_monitor_command (ThreadId tid
, HChar
*req
)
1864 HChar s
[VG_(strlen
)(req
) + 1]; /* copy for strtok_r */
1867 VG_(strcpy
) (s
, req
);
1869 wcmd
= VG_(strtok_r
) (s
, " ", &ssaveptr
);
1870 switch (VG_(keyword_id
) ("help snapshot detailed_snapshot all_snapshots"
1872 wcmd
, kwd_report_duplicated_matches
)) {
1873 case -2: /* multiple matches */
1875 case -1: /* not found */
1878 print_monitor_help();
1880 case 1: { /* snapshot */
1882 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1883 handle_snapshot_monitor_command (filename
, False
/* detailed */);
1886 case 2: { /* detailed_snapshot */
1888 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1889 handle_snapshot_monitor_command (filename
, True
/* detailed */);
1892 case 3: { /* all_snapshots */
1894 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1895 handle_all_snapshots_monitor_command (filename
);
1898 case 4: { /* xtmemory */
1900 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1901 ms_xtmemory_report (filename
, False
);
1910 static void ms_print_stats (void)
1912 #define STATS(format, args...) \
1913 VG_(dmsg)("Massif: " format, ##args)
1915 STATS("heap allocs: %u\n", n_heap_allocs
);
1916 STATS("heap reallocs: %u\n", n_heap_reallocs
);
1917 STATS("heap frees: %u\n", n_heap_frees
);
1918 STATS("ignored heap allocs: %u\n", n_ignored_heap_allocs
);
1919 STATS("ignored heap frees: %u\n", n_ignored_heap_frees
);
1920 STATS("ignored heap reallocs: %u\n", n_ignored_heap_reallocs
);
1921 STATS("stack allocs: %u\n", n_stack_allocs
);
1922 STATS("skipped snapshots: %u\n", n_skipped_snapshots
);
1923 STATS("real snapshots: %u\n", n_real_snapshots
);
1924 STATS("detailed snapshots: %u\n", n_detailed_snapshots
);
1925 STATS("peak snapshots: %u\n", n_peak_snapshots
);
1926 STATS("cullings: %u\n", n_cullings
);
1931 //------------------------------------------------------------//
1932 //--- Finalisation ---//
1933 //------------------------------------------------------------//
1935 static void ms_fini(Int exit_status
)
1937 ms_xtmemory_report(VG_(clo_xtree_memory_file
), True
);
1940 write_snapshots_array_to_file();
1947 //------------------------------------------------------------//
1948 //--- Initialisation ---//
1949 //------------------------------------------------------------//
1951 static void ms_post_clo_init(void)
1954 HChar
* LD_PRELOAD_val
;
1956 /* We will record execontext up to clo_depth + overestimate and
1957 we will store this as ec => we need to increase the backtrace size
1958 if smaller than what we will store. */
1959 if (VG_(clo_backtrace_size
) < clo_depth
+ MAX_OVERESTIMATE
)
1960 VG_(clo_backtrace_size
) = clo_depth
+ MAX_OVERESTIMATE
;
1963 if (clo_pages_as_heap
) {
1965 VG_(fmsg_bad_option
)("--pages-as-heap=yes",
1966 "Cannot be used together with --stacks=yes");
1970 clo_pages_as_heap
= False
;
1973 // If --pages-as-heap=yes we don't want malloc replacement to occur. So we
1974 // disable vgpreload_massif-$PLATFORM.so by removing it from LD_PRELOAD (or
1975 // platform-equivalent). This is a bit of a hack, but LD_PRELOAD is setup
1976 // well before tool initialisation, so this seems the best way to do it.
1977 if (clo_pages_as_heap
) {
1981 clo_heap_admin
= 0; // No heap admin on pages.
1983 LD_PRELOAD_val
= VG_(getenv
)( VG_(LD_PRELOAD_var_name
) );
1984 tl_assert(LD_PRELOAD_val
);
1986 VERB(2, "clo_pages_as_heap orig LD_PRELOAD '%s'\n", LD_PRELOAD_val
);
1988 // Make sure the vgpreload_core-$PLATFORM entry is there, for sanity.
1989 s1
= VG_(strstr
)(LD_PRELOAD_val
, "vgpreload_core");
1992 // Now find the vgpreload_massif-$PLATFORM entry.
1993 s1
= VG_(strstr
)(LD_PRELOAD_val
, "vgpreload_massif");
1997 // Position s1 on the previous ':', which must be there because
1998 // of the preceding vgpreload_core-$PLATFORM entry.
1999 for (; *s1
!= ':'; s1
--)
2002 // Position s2 on the next ':' or \0
2003 for (; *s2
!= ':' && *s2
!= '\0'; s2
++)
2006 // Move all characters from s2 to s1
2007 while ((*s1
++ = *s2
++))
2010 VERB(2, "clo_pages_as_heap cleaned LD_PRELOAD '%s'\n", LD_PRELOAD_val
);
2013 // Print alloc-fns and ignore-fns, if necessary.
2014 if (VG_(clo_verbosity
) > 1) {
2015 VERB(1, "alloc-fns:\n");
2016 for (i
= 0; i
< VG_(sizeXA
)(alloc_fns
); i
++) {
2017 HChar
** fn_ptr
= VG_(indexXA
)(alloc_fns
, i
);
2018 VERB(1, " %s\n", *fn_ptr
);
2021 VERB(1, "ignore-fns:\n");
2022 if (0 == VG_(sizeXA
)(ignore_fns
)) {
2023 VERB(1, " <empty>\n");
2025 for (i
= 0; i
< VG_(sizeXA
)(ignore_fns
); i
++) {
2026 HChar
** fn_ptr
= VG_(indexXA
)(ignore_fns
, i
);
2027 VERB(1, " %d: %s\n", i
, *fn_ptr
);
2033 VG_(track_new_mem_stack
) ( new_mem_stack
);
2034 VG_(track_die_mem_stack
) ( die_mem_stack
);
2035 VG_(track_new_mem_stack_signal
) ( new_mem_stack_signal
);
2036 VG_(track_die_mem_stack_signal
) ( die_mem_stack_signal
);
2039 if (clo_pages_as_heap
) {
2040 VG_(track_new_mem_startup
) ( ms_new_mem_startup
);
2041 VG_(track_new_mem_brk
) ( ms_new_mem_brk
);
2042 VG_(track_new_mem_mmap
) ( ms_new_mem_mmap
);
2044 VG_(track_copy_mem_remap
) ( ms_copy_mem_remap
);
2046 VG_(track_die_mem_brk
) ( ms_die_mem_brk
);
2047 VG_(track_die_mem_munmap
) ( ms_die_mem_munmap
);
2050 // Initialise snapshot array, and sanity-check it.
2051 snapshots
= VG_(malloc
)("ms.main.mpoci.1",
2052 sizeof(Snapshot
) * clo_max_snapshots
);
2053 // We don't want to do snapshot sanity checks here, because they're
2054 // currently uninitialised.
2055 for (i
= 0; i
< clo_max_snapshots
; i
++) {
2056 clear_snapshot( & snapshots
[i
], /*do_sanity_check*/False
);
2058 sanity_check_snapshots_array();
2060 if (VG_(clo_xtree_memory
) == Vg_XTMemory_Full
)
2061 // Activate full xtree memory profiling.
2062 // As massif already filters one top function, use as filter
2063 // VG_(XT_filter_maybe_below_main).
2064 VG_(XTMemory_Full_init
)(VG_(XT_filter_maybe_below_main
));
2068 static void ms_pre_clo_init(void)
2070 VG_(details_name
) ("Massif");
2071 VG_(details_version
) (NULL
);
2072 VG_(details_description
) ("a heap profiler");
2073 VG_(details_copyright_author
)(
2074 "Copyright (C) 2003-2017, and GNU GPL'd, by Nicholas Nethercote");
2075 VG_(details_bug_reports_to
) (VG_BUGS_TO
);
2077 VG_(details_avg_translation_sizeB
) ( 330 );
2079 VG_(clo_vex_control
).iropt_register_updates_default
2080 = VG_(clo_px_file_backed
)
2081 = VexRegUpdSpAtMemAccess
; // overridable by the user.
2084 VG_(basic_tool_funcs
) (ms_post_clo_init
,
2089 VG_(needs_libc_freeres
)();
2090 VG_(needs_cxx_freeres
)();
2091 VG_(needs_command_line_options
)(ms_process_cmd_line_option
,
2093 ms_print_debug_usage
);
2094 VG_(needs_client_requests
) (ms_handle_client_request
);
2095 VG_(needs_sanity_checks
) (ms_cheap_sanity_check
,
2096 ms_expensive_sanity_check
);
2097 VG_(needs_print_stats
) (ms_print_stats
);
2098 VG_(needs_malloc_replacement
) (ms_malloc
,
2100 ms___builtin_vec_new
,
2104 ms___builtin_delete
,
2105 ms___builtin_vec_delete
,
2107 ms_malloc_usable_size
,
2111 HP_chunk_poolalloc
= VG_(newPA
)
2115 "massif MC_Chunk pool",
2117 malloc_list
= VG_(HT_construct
)( "Massif's malloc list" );
2120 heap_xt
= VG_(XT_create
)(VG_(malloc
),
2124 init_szB
, add_szB
, sub_szB
,
2127 // Initialise alloc_fns and ignore_fns.
2131 // Initialise args_for_massif.
2132 args_for_massif
= VG_(newXA
)(VG_(malloc
), "ms.main.mprci.1",
2133 VG_(free
), sizeof(HChar
*));
2136 VG_DETERMINE_INTERFACE_VERSION(ms_pre_clo_init
)
2138 //--------------------------------------------------------------------//
2140 //--------------------------------------------------------------------//