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, see <http://www.gnu.org/licenses/>.
25 The GNU General Public License is contained in the file COPYING.
28 //---------------------------------------------------------------------------
30 //---------------------------------------------------------------------------
31 // Todo -- nice, but less critical:
32 // - do a graph-drawing test
33 // - make file format more generic. Obstacles:
34 // - unit prefixes are not generic
35 // - preset column widths for stats are not generic
36 // - preset column headers are not generic
37 // - "Massif arguments:" line is not generic
38 // - do snapshots on some specific client requests
39 // - "show me the extra allocations since the last snapshot"
40 // - "start/stop logging" (eg. quickly skip boring bits)
41 // - Add ability to draw multiple graphs, eg. heap-only, stack-only, total.
42 // Give each graph a title. (try to do it generically!)
43 // - make --show-below-main=no work
44 // - Options like --alloc-fn='operator new(unsigned, std::nothrow_t const&)'
45 // don't work in a .valgrindrc file or in $VALGRIND_OPTS.
46 // m_commandline.c:add_args_from_string() needs to respect single quotes.
47 // - With --stack=yes, want to add a stack trace for detailed snapshots so
48 // it's clear where/why the peak is occurring. (Mattieu Castet) Also,
49 // possibly useful even with --stack=no? (Andi Yin)
52 // - To run the benchmarks:
54 // perl perf/vg_perf --tools=massif --reps=3 perf/{heap,tinycc} massif
55 // time valgrind --tool=massif --depth=100 konqueror
57 // The other benchmarks don't do much allocation, and so give similar speeds
60 // Timing results on 'nevermore' (njn's machine) as of r7013:
62 // heap 0.53s ma:12.4s (23.5x, -----)
63 // tinycc 0.46s ma: 4.9s (10.7x, -----)
64 // many-xpts 0.08s ma: 2.0s (25.0x, -----)
65 // konqueror 29.6s real 0:21.0s user
67 // [Introduction of --time-unit=i as the default slowed things down by
70 // Todo -- low priority:
71 // - In each XPt, record both bytes and the number of allocations, and
72 // possibly the global number of allocations.
73 // - (Andy Lin) Give a stack trace on detailed snapshots?
74 // - (Artur Wisz) add a feature to Massif to ignore any heap blocks larger
75 // than a certain size! Because: "linux's malloc allows to set a
76 // MMAP_THRESHOLD value, so we set it to 4096 - all blocks above that will
77 // be handled directly by the kernel, and are guaranteed to be returned to
78 // the system when freed. So we needed to profile only blocks below this
81 // File format working notes:
84 desc
: --heap
-admin
=foo
103 n1
: 5 (heap allocation functions
) malloc
/new/new[], --alloc
-fns
, etc
.
104 n1
: 5 0x27F6E0: _nl_normalize_codeset (in
/lib
/libc
-2.3.5.so
)
105 n1
: 5 0x279DE6: _nl_load_locale_from_archive (in
/lib
/libc
-2.3.5.so
)
106 n1
: 5 0x278E97: _nl_find_locale (in
/lib
/libc
-2.3.5.so
)
107 n1
: 5 0x278871: setlocale (in
/lib
/libc
-2.3.5.so
)
108 n1
: 5 0x8049821: (within
/bin
/date
)
109 n0
: 5 0x26ED5E: (below main
) (in
/lib
/libc
-2.3.5.so
)
112 n_events
: n
time(ms
) total(B
) useful
-heap(B
) admin
-heap(B
) stacks(B
)
120 - each snapshot specifies an x
-axis value
and one
or more y
-axis values
.
121 - can display the y
-axis values separately
if you like
122 - can completely separate connection between snapshots
and trees
.
125 - how to specify
and scale
/abbreviate units on axes
?
126 - how to combine multiple values into the y
-axis
?
128 --------------------------------------------------------------------------------Command
: date
129 Massif arguments
: --heap
-admin
=foo
130 ms_print arguments
: massif
.out
131 --------------------------------------------------------------------------------
136 | ::@
:@
:@
:@
:::# :: : ::::
137 0 +-----------------------------------@
---@
---@
-----@
--@
---#-------------->ms 0 713
139 Number of snapshots
: 50
140 Detailed snapshots
: [2, 11, 13, 19, 25, 32 (peak
)]
141 -------------------------------------------------------------------------------- n
time(ms
) total(B
) useful
-heap(B
) admin
-heap(B
) stacks(B
)
142 -------------------------------------------------------------------------------- 0 0 0 0 0 0
145 100.00% (5B
) (heap allocation functions
) malloc
/new/new[], --alloc
-fns
, etc
.
146 ->100.00% (5B
) 0x27F6E0: _nl_normalize_codeset (in
/lib
/libc
-2.3.5.so
)
149 //---------------------------------------------------------------------------
151 #include "pub_tool_basics.h"
152 #include "pub_tool_vki.h"
153 #include "pub_tool_aspacemgr.h"
154 #include "pub_tool_debuginfo.h"
155 #include "pub_tool_hashtable.h"
156 #include "pub_tool_libcbase.h"
157 #include "pub_tool_libcassert.h"
158 #include "pub_tool_libcfile.h"
159 #include "pub_tool_libcprint.h"
160 #include "pub_tool_libcproc.h"
161 #include "pub_tool_machine.h"
162 #include "pub_tool_mallocfree.h"
163 #include "pub_tool_options.h"
164 #include "pub_tool_poolalloc.h"
165 #include "pub_tool_replacemalloc.h"
166 #include "pub_tool_stacktrace.h"
167 #include "pub_tool_threadstate.h"
168 #include "pub_tool_tooliface.h"
169 #include "pub_tool_xarray.h"
170 #include "pub_tool_xtree.h"
171 #include "pub_tool_xtmemory.h"
172 #include "pub_tool_clientstate.h"
173 #include "pub_tool_gdbserver.h"
175 #include "pub_tool_clreq.h" // For {MALLOC,FREE}LIKE_BLOCK
177 //------------------------------------------------------------*/
178 //--- Overview of operation ---*/
179 //------------------------------------------------------------*/
181 // The size of the stacks and heap is tracked. The heap is tracked in a lot
182 // of detail, enough to tell how many bytes each line of code is responsible
183 // for, more or less. The main data structure is an xtree maintaining the
184 // call tree beneath all the allocation functions like malloc().
185 // (Alternatively, if --pages-as-heap=yes is specified, memory is tracked at
186 // the page level, and each page is treated much like a heap block. We use
187 // "heap" throughout below to cover this case because the concepts are all the
190 // "Snapshots" are recordings of the memory usage. There are two basic
192 // - Normal: these record the current time, total memory size, total heap
193 // size, heap admin size and stack size.
194 // - Detailed: these record those things in a normal snapshot, plus a very
195 // detailed XTree (see below) indicating how the heap is structured.
197 // Snapshots are taken every so often. There are two storage classes of
199 // - Temporary: Massif does a temporary snapshot every so often. The idea
200 // is to always have a certain number of temporary snapshots around. So
201 // we take them frequently to begin with, but decreasingly often as the
202 // program continues to run. Also, we remove some old ones after a while.
203 // Overall it's a kind of exponential decay thing. Most of these are
204 // normal snapshots, a small fraction are detailed snapshots.
205 // - Permanent: Massif takes a permanent (detailed) snapshot in some
206 // circumstances. They are:
207 // - Peak snapshot: When the memory usage peak is reached, it takes a
208 // snapshot. It keeps this, unless the peak is subsequently exceeded,
209 // in which case it will overwrite the peak snapshot.
210 // - User-requested snapshots: These are done in response to client
211 // requests. They are always kept.
213 // Used for printing things when clo_verbosity > 1.
214 #define VERB(verb, format, args...) \
215 if (UNLIKELY(VG_(clo_verbosity) > verb)) { \
216 VG_(dmsg)("Massif: " format, ##args); \
219 //------------------------------------------------------------//
220 //--- Statistics ---//
221 //------------------------------------------------------------//
223 // Konqueror startup, to give an idea of the numbers involved with a biggish
224 // program, with default depth:
227 // - 310,000 allocations
229 // - 15,000 XPts 800,000 XPts
232 static UInt n_heap_allocs
= 0;
233 static UInt n_heap_reallocs
= 0;
234 static UInt n_heap_frees
= 0;
235 static UInt n_ignored_heap_allocs
= 0;
236 static UInt n_ignored_heap_frees
= 0;
237 static UInt n_ignored_heap_reallocs
= 0;
238 static UInt n_stack_allocs
= 0;
239 static UInt n_stack_frees
= 0;
241 static UInt n_skipped_snapshots
= 0;
242 static UInt n_real_snapshots
= 0;
243 static UInt n_detailed_snapshots
= 0;
244 static UInt n_peak_snapshots
= 0;
245 static UInt n_cullings
= 0;
247 //------------------------------------------------------------//
249 //------------------------------------------------------------//
251 // Number of guest instructions executed so far. Only used with
253 static Long guest_instrs_executed
= 0;
255 static SizeT heap_szB
= 0; // Live heap size
256 static SizeT heap_extra_szB
= 0; // Live heap extra size -- slop + admin bytes
257 static SizeT stacks_szB
= 0; // Live stacks size
259 // This is the total size from the current peak snapshot, or 0 if no peak
260 // snapshot has been taken yet.
261 static SizeT peak_snapshot_total_szB
= 0;
263 // Incremented every time memory is allocated/deallocated, by the
264 // allocated/deallocated amount; includes heap, heap-admin and stack
265 // memory. An alternative to milliseconds as a unit of program "time".
266 static ULong total_allocs_deallocs_szB
= 0;
268 // When running with --heap=yes --pages-as-heap=no, we don't start taking
269 // snapshots until the first basic block is executed, rather than doing it in
270 // ms_post_clo_init (which is the obvious spot), for two reasons.
271 // - It lets us ignore stack events prior to that, because they're not
272 // really proper ones and just would screw things up.
273 // - Because there's still some core initialisation to do, and so there
274 // would be an artificial time gap between the first and second snapshots.
276 // When running with --heap=yes --pages-as-heap=yes, snapshots start much
277 // earlier due to new_mem_startup so this isn't relevant.
279 static Bool have_started_executing_code
= False
;
281 //------------------------------------------------------------//
282 //--- Alloc fns ---//
283 //------------------------------------------------------------//
285 static XArray
* alloc_fns
;
286 static XArray
* ignore_fns
;
288 static void init_alloc_fns(void)
290 // Create the list, and add the default elements.
291 alloc_fns
= VG_(newXA
)(VG_(malloc
), "ms.main.iaf.1",
292 VG_(free
), sizeof(HChar
*));
293 #define DO(x) { const HChar* s = x; VG_(addToXA)(alloc_fns, &s); }
295 // Ordered roughly according to (presumed) frequency.
296 // Nb: The C++ "operator new*" ones are overloadable. We include them
297 // always anyway, because even if they're overloaded, it would be a
298 // prodigiously stupid overloading that caused them to not allocate
301 // XXX: because we don't look at the first stack entry (unless it's a
302 // custom allocation) there's not much point to having all these alloc
303 // functions here -- they should never appear anywhere (I think?) other
304 // than the top stack entry. The only exceptions are those that in
305 // vg_replace_malloc.c are partly or fully implemented in terms of another
306 // alloc function: realloc (which uses malloc); valloc,
307 // malloc_zone_valloc, posix_memalign and memalign_common (which use
311 DO("__builtin_new" );
312 DO("operator new(unsigned)" );
313 DO("operator new(unsigned long)" );
314 DO("__builtin_vec_new" );
315 DO("operator new[](unsigned)" );
316 DO("operator new[](unsigned long)" );
320 DO("posix_memalign" );
322 DO("operator new(unsigned, std::nothrow_t const&)" );
323 DO("operator new[](unsigned, std::nothrow_t const&)" );
324 DO("operator new(unsigned long, std::nothrow_t const&)" );
325 DO("operator new[](unsigned long, std::nothrow_t const&)");
326 #if defined(VGO_darwin)
327 DO("malloc_zone_malloc" );
328 DO("malloc_zone_calloc" );
329 DO("malloc_zone_realloc" );
330 DO("malloc_zone_memalign" );
331 DO("malloc_zone_valloc" );
335 static void init_ignore_fns(void)
337 // Create the (empty) list.
338 ignore_fns
= VG_(newXA
)(VG_(malloc
), "ms.main.iif.1",
339 VG_(free
), sizeof(HChar
*));
342 //------------------------------------------------------------//
343 //--- Command line args ---//
344 //------------------------------------------------------------//
346 #define MAX_DEPTH 200
348 typedef enum { TimeI
, TimeMS
, TimeB
} TimeUnit
;
350 static const HChar
* TimeUnit_to_string(TimeUnit time_unit
)
353 case TimeI
: return "i";
354 case TimeMS
: return "ms";
355 case TimeB
: return "B";
356 default: tl_assert2(0, "TimeUnit_to_string: unrecognised TimeUnit");
360 static Bool clo_heap
= True
;
361 // clo_heap_admin is deliberately a word-sized type. At one point it was
362 // a UInt, but this caused problems on 64-bit machines when it was
363 // multiplied by a small negative number and then promoted to a
364 // word-sized type -- it ended up with a value of 4.2 billion. Sigh.
365 static SSizeT clo_heap_admin
= 8;
366 static Bool clo_pages_as_heap
= False
;
367 static Bool clo_stacks
= False
;
368 static Int clo_depth
= 30;
369 static double clo_threshold
= 1.0; // percentage
370 static double clo_peak_inaccuracy
= 1.0; // percentage
371 static Int clo_time_unit
= TimeI
;
372 static Int clo_detailed_freq
= 10;
373 static Int clo_max_snapshots
= 100;
374 static const HChar
* clo_massif_out_file
= "massif.out.%p";
376 static XArray
* args_for_massif
;
378 static Bool
ms_process_cmd_line_option(const HChar
* arg
)
380 const HChar
* tmp_str
;
382 // Remember the arg for later use.
383 VG_(addToXA
)(args_for_massif
, &arg
);
385 if VG_BOOL_CLO(arg
, "--heap", clo_heap
) {}
386 else if VG_BINT_CLO(arg
, "--heap-admin", clo_heap_admin
, 0, 1024) {}
388 else if VG_BOOL_CLO(arg
, "--stacks", clo_stacks
) {}
390 else if VG_BOOL_CLO(arg
, "--pages-as-heap", clo_pages_as_heap
) {}
392 else if VG_BINT_CLO(arg
, "--depth", clo_depth
, 1, MAX_DEPTH
) {}
394 else if VG_STR_CLO(arg
, "--alloc-fn", tmp_str
) {
395 VG_(addToXA
)(alloc_fns
, &tmp_str
);
397 else if VG_STR_CLO(arg
, "--ignore-fn", tmp_str
) {
398 VG_(addToXA
)(ignore_fns
, &tmp_str
);
401 else if VG_DBL_CLO(arg
, "--threshold", clo_threshold
) {
402 if (clo_threshold
< 0 || clo_threshold
> 100) {
403 VG_(fmsg_bad_option
)(arg
,
404 "--threshold must be between 0.0 and 100.0\n");
408 else if VG_DBL_CLO(arg
, "--peak-inaccuracy", clo_peak_inaccuracy
) {}
410 else if VG_XACT_CLO(arg
, "--time-unit=i", clo_time_unit
, TimeI
) {}
411 else if VG_XACT_CLO(arg
, "--time-unit=ms", clo_time_unit
, TimeMS
) {}
412 else if VG_XACT_CLO(arg
, "--time-unit=B", clo_time_unit
, TimeB
) {}
414 else if VG_BINT_CLO(arg
, "--detailed-freq", clo_detailed_freq
, 1, 1000000) {}
416 else if VG_BINT_CLO(arg
, "--max-snapshots", clo_max_snapshots
, 10, 1000) {}
418 else if VG_STR_CLO(arg
, "--massif-out-file", clo_massif_out_file
) {}
421 return VG_(replacement_malloc_process_cmd_line_option
)(arg
);
426 static void ms_print_usage(void)
429 " --heap=no|yes profile heap blocks [yes]\n"
430 " --heap-admin=<size> average admin bytes per heap block;\n"
431 " ignored if --heap=no [8]\n"
432 " --stacks=no|yes profile stack(s) [no]\n"
433 " --pages-as-heap=no|yes profile memory at the page level [no]\n"
434 " --depth=<number> depth of contexts [30]\n"
435 " --alloc-fn=<name> specify <name> as an alloc function [empty]\n"
436 " --ignore-fn=<name> ignore heap allocations within <name> [empty]\n"
437 " --threshold=<m.n> significance threshold, as a percentage [1.0]\n"
438 " --peak-inaccuracy=<m.n> maximum peak inaccuracy, as a percentage [1.0]\n"
439 " --time-unit=i|ms|B time unit: instructions executed, milliseconds\n"
440 " or heap bytes alloc'd/dealloc'd [i]\n"
441 " --detailed-freq=<N> every Nth snapshot should be detailed [10]\n"
442 " --max-snapshots=<N> maximum number of snapshots recorded [100]\n"
443 " --massif-out-file=<file> output file name [massif.out.%%p]\n"
447 static void ms_print_debug_usage(void)
455 //------------------------------------------------------------//
457 //------------------------------------------------------------//
459 // The details of the heap are represented by a single XTree.
460 // This XTree maintains the nr of allocated bytes for each
461 // stacktrace/execontext.
463 // The root of the Xtree will be output as a top node 'alloc functions',
464 // which represents all allocation functions, eg:
465 // - malloc/calloc/realloc/memalign/new/new[];
466 // - user-specified allocation functions (using --alloc-fn);
467 // - custom allocation (MALLOCLIKE) points
468 static XTree
* heap_xt
;
469 /* heap_xt contains a SizeT: the nr of allocated bytes by this execontext. */
470 static void init_szB(void* value
)
472 *((SizeT
*)value
) = 0;
474 static void add_szB(void* to
, const void* value
)
476 *((SizeT
*)to
) += *((const SizeT
*)value
);
478 static void sub_szB(void* from
, const void* value
)
480 *((SizeT
*)from
) -= *((const SizeT
*)value
);
482 static ULong
alloc_szB(const void* value
)
484 return (ULong
)*((const SizeT
*)value
);
488 //------------------------------------------------------------//
489 //--- XTree Operations ---//
490 //------------------------------------------------------------//
492 // This is the limit on the number of filtered alloc-fns that can be in a
493 // single stacktrace.
494 #define MAX_OVERESTIMATE 50
495 #define MAX_IPS (MAX_DEPTH + MAX_OVERESTIMATE)
497 // filtering out uninteresting entries:
498 // alloc-fns and entries above alloc-fns, and entries below main-or-below-main.
499 // Eg: alloc-fn1 / alloc-fn2 / a / b / main / (below main) / c
500 // becomes: a / b / main
501 // Nb: it's possible to end up with an empty trace, eg. if 'main' is marked
502 // as an alloc-fn. This is ok.
504 void filter_IPs (Addr
* ips
, Int n_ips
,
505 UInt
* top
, UInt
* n_ips_sel
)
508 Bool top_has_fnname
= False
;
509 Bool is_alloc_fn
= False
;
510 Bool is_inline_fn
= 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 const DiEpoch ep
= VG_(current_DiEpoch
)();
524 InlIPCursor
*iipc
= NULL
;
526 for (i
= *top
; i
< n_ips
; ++i
) {
527 iipc
= VG_(new_IIPC
)(ep
, ips
[i
]);
529 top_has_fnname
= VG_(get_fnname_inl
)(ep
, ips
[i
], &fnname
, iipc
);
530 is_alloc_fn
= top_has_fnname
&& VG_(strIsMemberXA
)(alloc_fns
, fnname
);
531 is_inline_fn
= VG_(next_IIPC
)(iipc
);
532 if (is_alloc_fn
&& is_inline_fn
) {
533 VERB(4, "filtering inline alloc fn %s\n", fnname
);
535 } while (is_alloc_fn
&& is_inline_fn
);
536 VG_(delete_IIPC
)(iipc
);
539 VERB(4, "filtering alloc fn %s\n", fnname
);
547 // filter the whole stacktrace if this allocation has to be ignored.
548 if (*n_ips_sel
> 0 && VG_(sizeXA
)(ignore_fns
) > 0) {
549 if (!top_has_fnname
) {
550 // top has no fnname => search for the first entry that has a fnname
551 for (i
= *top
; i
< n_ips
&& !top_has_fnname
; ++i
) {
552 iipc
= VG_(new_IIPC
)(ep
, ips
[i
]);
554 top_has_fnname
= VG_(get_fnname_inl
)(ep
, ips
[i
], &fnname
, iipc
);
555 if (top_has_fnname
) {
558 } while (VG_(next_IIPC
)(iipc
));
559 VG_(delete_IIPC
)(iipc
);
562 if (top_has_fnname
&& VG_(strIsMemberXA
)(ignore_fns
, fnname
)) {
563 VERB(4, "ignored allocation from fn %s\n", fnname
);
569 if (!VG_(clo_show_below_main
) && *n_ips_sel
> 0 ) {
570 // Technically, it would be better to use the 'real' epoch that
571 // was used to capture ips/n_ips. However, this searches
572 // for a main or below_main function. It is technically possible
573 // but unlikely that main or below main fn is in a dlclose-d library,
574 // so current epoch is reasonable enough, even if not perfect.
575 // FIXME PW EPOCH: would be better to also use the real ips epoch here,
576 // once m_xtree.c massif output format properly supports epoch.
577 const DiEpoch cur_ep
= VG_(current_DiEpoch
)();
578 Int mbm
= VG_(XT_offset_main_or_below_main
)(cur_ep
, ips
, n_ips
);
581 // Special case: the first main (or below main) function is an
584 VERB(4, "main/below main: keeping 1 fn\n");
586 *n_ips_sel
-= n_ips
- mbm
- 1;
587 VERB(4, "main/below main: filtering %d\n", n_ips
- mbm
- 1);
591 // filter the frames if we have more than clo_depth
592 if (*n_ips_sel
> clo_depth
) {
593 VERB(4, "filtering IPs above clo_depth\n");
594 *n_ips_sel
= clo_depth
;
598 // Capture a stacktrace, and make an ec of it, without the first entry
599 // if exclude_first_entry is True.
600 static ExeContext
* make_ec(ThreadId tid
, Bool exclude_first_entry
)
602 static Addr ips
[MAX_IPS
];
604 // After this call, the IPs we want are in ips[0]..ips[n_ips-1].
605 Int n_ips
= VG_(get_StackTrace
)( tid
, ips
, clo_depth
+ MAX_OVERESTIMATE
,
606 NULL
/*array to dump SP values in*/,
607 NULL
/*array to dump FP values in*/,
608 0/*first_ip_delta*/ );
609 if (exclude_first_entry
) {
612 VERB(4, "removing top fn %s from stacktrace\n",
613 VG_(get_fnname
)(VG_(current_DiEpoch
)(), ips
[0], &fnname
)
615 return VG_(make_ExeContext_from_StackTrace
)(ips
+1, n_ips
-1);
617 VERB(4, "null execontext as removing top fn with n_ips %d\n", n_ips
);
618 return VG_(null_ExeContext
) ();
621 return VG_(make_ExeContext_from_StackTrace
)(ips
, n_ips
);
624 // Create (or update) in heap_xt an xec corresponding to the stacktrace of tid.
625 // req_szB is added to the xec (unless ec is fully filtered).
626 // Returns the correspding XTree xec.
627 // exclude_first_entry is an optimisation: if True, automatically removes
628 // the top level IP from the stacktrace. Should be set to True if it is known
629 // that this is an alloc fn. The top function presumably will be something like
630 // malloc or __builtin_new that we're sure to filter out).
631 static Xecu
add_heap_xt( ThreadId tid
, SizeT req_szB
, Bool exclude_first_entry
)
633 ExeContext
*ec
= make_ec(tid
, exclude_first_entry
);
635 if (UNLIKELY(VG_(clo_xtree_memory
) == Vg_XTMemory_Full
))
636 VG_(XTMemory_Full_alloc
)(req_szB
, ec
);
637 return VG_(XT_add_to_ec
) (heap_xt
, ec
, &req_szB
);
640 // Substract req_szB from the heap_xt where.
641 static void sub_heap_xt(Xecu where
, SizeT req_szB
, Bool exclude_first_entry
)
648 VG_(XT_sub_from_xecu
) (heap_xt
, where
, &req_szB
);
649 if (UNLIKELY(VG_(clo_xtree_memory
) == Vg_XTMemory_Full
)) {
650 ExeContext
*ec_free
= make_ec(VG_(get_running_tid
)(),
651 exclude_first_entry
);
652 VG_(XTMemory_Full_free
)(req_szB
,
653 VG_(XT_get_ec_from_xecu
)(heap_xt
, where
),
659 //------------------------------------------------------------//
660 //--- Snapshots ---//
661 //------------------------------------------------------------//
663 // Snapshots are done in a way so that we always have a reasonable number of
664 // them. We start by taking them quickly. Once we hit our limit, we cull
665 // some (eg. half), and start taking them more slowly. Once we hit the
666 // limit again, we again cull and then take them even more slowly, and so
669 #define UNUSED_SNAPSHOT_TIME -333 // A conspicuous negative number.
684 SizeT heap_extra_szB
;// Heap slop + admin bytes.
686 XTree
* xt
; // Snapshot of heap_xt, if a detailed snapshot,
690 static UInt next_snapshot_i
= 0; // Index of where next snapshot will go.
691 static Snapshot
* snapshots
; // Array of snapshots.
693 static Bool
is_snapshot_in_use(Snapshot
* snapshot
)
695 if (Unused
== snapshot
->kind
) {
696 // If snapshot is unused, check all the fields are unset.
697 tl_assert(snapshot
->time
== UNUSED_SNAPSHOT_TIME
);
698 tl_assert(snapshot
->heap_extra_szB
== 0);
699 tl_assert(snapshot
->heap_szB
== 0);
700 tl_assert(snapshot
->stacks_szB
== 0);
701 tl_assert(snapshot
->xt
== NULL
);
704 tl_assert(snapshot
->time
!= UNUSED_SNAPSHOT_TIME
);
709 static Bool
is_detailed_snapshot(Snapshot
* snapshot
)
711 return (snapshot
->xt
? True
: False
);
714 static Bool
is_uncullable_snapshot(Snapshot
* snapshot
)
716 return &snapshots
[0] == snapshot
// First snapshot
717 || &snapshots
[next_snapshot_i
-1] == snapshot
// Last snapshot
718 || snapshot
->kind
== Peak
; // Peak snapshot
721 static void sanity_check_snapshot(Snapshot
* snapshot
)
723 // Not much we can sanity check.
724 tl_assert(snapshot
->xt
== NULL
|| snapshot
->kind
!= Unused
);
727 // All the used entries should look used, all the unused ones should be clear.
728 static void sanity_check_snapshots_array(void)
731 for (i
= 0; i
< next_snapshot_i
; i
++) {
732 tl_assert( is_snapshot_in_use( & snapshots
[i
] ));
734 for ( ; i
< clo_max_snapshots
; i
++) {
735 tl_assert(!is_snapshot_in_use( & snapshots
[i
] ));
739 // This zeroes all the fields in the snapshot, but does not free the xt
740 // XTree if present. It also does a sanity check unless asked not to; we
741 // can't sanity check at startup when clearing the initial snapshots because
742 // they're full of junk.
743 static void clear_snapshot(Snapshot
* snapshot
, Bool do_sanity_check
)
745 if (do_sanity_check
) sanity_check_snapshot(snapshot
);
746 snapshot
->kind
= Unused
;
747 snapshot
->time
= UNUSED_SNAPSHOT_TIME
;
748 snapshot
->heap_extra_szB
= 0;
749 snapshot
->heap_szB
= 0;
750 snapshot
->stacks_szB
= 0;
754 // This zeroes all the fields in the snapshot, and frees the heap XTree xt if
756 static void delete_snapshot(Snapshot
* snapshot
)
758 // Nb: if there's an XTree, we free it after calling clear_snapshot,
759 // because clear_snapshot does a sanity check which includes checking the
761 XTree
* tmp_xt
= snapshot
->xt
;
762 clear_snapshot(snapshot
, /*do_sanity_check*/True
);
764 VG_(XT_delete
)(tmp_xt
);
768 static void VERB_snapshot(Int verbosity
, const HChar
* prefix
, Int i
)
770 Snapshot
* snapshot
= &snapshots
[i
];
772 switch (snapshot
->kind
) {
773 case Peak
: suffix
= "p"; break;
774 case Normal
: suffix
= ( is_detailed_snapshot(snapshot
) ? "d" : "." ); break;
775 case Unused
: suffix
= "u"; break;
777 tl_assert2(0, "VERB_snapshot: unknown snapshot kind: %d", snapshot
->kind
);
779 VERB(verbosity
, "%s S%s%3d (t:%lld, hp:%lu, ex:%lu, st:%lu)\n",
783 snapshot
->heap_extra_szB
,
788 // Cull half the snapshots; we choose those that represent the smallest
789 // time-spans, because that gives us the most even distribution of snapshots
790 // over time. (It's possible to lose interesting spikes, however.)
792 // Algorithm for N snapshots: We find the snapshot representing the smallest
793 // timeframe, and remove it. We repeat this until (N/2) snapshots are gone.
794 // We have to do this one snapshot at a time, rather than finding the (N/2)
795 // smallest snapshots in one hit, because when a snapshot is removed, its
796 // neighbours immediately cover greater timespans. So it's O(N^2), but N is
797 // small, and it's not done very often.
799 // Once we're done, we return the new smallest interval between snapshots.
800 // That becomes our minimum time interval.
801 static UInt
cull_snapshots(void)
803 Int i
, jp
, j
, jn
, min_timespan_i
;
809 // Sets j to the index of the first not-yet-removed snapshot at or after i
810 #define FIND_SNAPSHOT(i, j) \
812 j < clo_max_snapshots && !is_snapshot_in_use(&snapshots[j]); \
815 VERB(2, "Culling...\n");
817 // First we remove enough snapshots by clearing them in-place. Once
818 // that's done, we can slide the remaining ones down.
819 for (i
= 0; i
< clo_max_snapshots
/2; i
++) {
820 // Find the snapshot representing the smallest timespan. The timespan
821 // for snapshot n = d(N-1,N)+d(N,N+1), where d(A,B) is the time between
822 // snapshot A and B. We don't consider the first and last snapshots for
824 Snapshot
* min_snapshot
;
827 // Initial triple: (prev, curr, next) == (jp, j, jn)
828 // Initial min_timespan is the first one.
831 FIND_SNAPSHOT(j
+1, jn
);
832 min_timespan
= 0x7fffffffffffffffLL
;
834 while (jn
< clo_max_snapshots
) {
835 Time timespan
= snapshots
[jn
].time
- snapshots
[jp
].time
;
836 tl_assert(timespan
>= 0);
837 // Nb: We never cull the peak snapshot.
838 if (Peak
!= snapshots
[j
].kind
&& timespan
< min_timespan
) {
839 min_timespan
= timespan
;
842 // Move on to next triple
845 FIND_SNAPSHOT(jn
+1, jn
);
847 // We've found the least important snapshot, now delete it. First
848 // print it if necessary.
849 tl_assert(-1 != min_j
); // Check we found a minimum.
850 min_snapshot
= & snapshots
[ min_j
];
851 if (VG_(clo_verbosity
) > 1) {
852 HChar buf
[64]; // large enough
853 VG_(snprintf
)(buf
, 64, " %3d (t-span = %lld)", i
, min_timespan
);
854 VERB_snapshot(2, buf
, min_j
);
856 delete_snapshot(min_snapshot
);
860 // Slide down the remaining snapshots over the removed ones. First set i
861 // to point to the first empty slot, and j to the first full slot after
862 // i. Then slide everything down.
863 for (i
= 0; is_snapshot_in_use( &snapshots
[i
] ); i
++) { }
864 for (j
= i
; !is_snapshot_in_use( &snapshots
[j
] ); j
++) { }
865 for ( ; j
< clo_max_snapshots
; j
++) {
866 if (is_snapshot_in_use( &snapshots
[j
] )) {
867 snapshots
[i
++] = snapshots
[j
];
868 clear_snapshot(&snapshots
[j
], /*do_sanity_check*/True
);
873 // Check snapshots array looks ok after changes.
874 sanity_check_snapshots_array();
876 // Find the minimum timespan remaining; that will be our new minimum
877 // time interval. Note that above we were finding timespans by measuring
878 // two intervals around a snapshot that was under consideration for
879 // deletion. Here we only measure single intervals because all the
880 // deletions have occurred.
882 // But we have to be careful -- some snapshots (eg. snapshot 0, and the
883 // peak snapshot) are uncullable. If two uncullable snapshots end up
884 // next to each other, they'll never be culled (assuming the peak doesn't
885 // change), and the time gap between them will not change. However, the
886 // time between the remaining cullable snapshots will grow ever larger.
887 // This means that the min_timespan found will always be that between the
888 // two uncullable snapshots, and it will be much smaller than it should
889 // be. To avoid this problem, when computing the minimum timespan, we
890 // ignore any timespans between two uncullable snapshots.
891 tl_assert(next_snapshot_i
> 1);
892 min_timespan
= 0x7fffffffffffffffLL
;
894 for (i
= 1; i
< next_snapshot_i
; i
++) {
895 if (is_uncullable_snapshot(&snapshots
[i
]) &&
896 is_uncullable_snapshot(&snapshots
[i
-1]))
898 VERB(2, "(Ignoring interval %d--%d when computing minimum)\n", i
-1, i
);
900 Time timespan
= snapshots
[i
].time
- snapshots
[i
-1].time
;
901 tl_assert(timespan
>= 0);
902 if (timespan
< min_timespan
) {
903 min_timespan
= timespan
;
908 tl_assert(-1 != min_timespan_i
); // Check we found a minimum.
910 // Print remaining snapshots, if necessary.
911 if (VG_(clo_verbosity
) > 1) {
912 VERB(2, "Finished culling (%3d of %3d deleted)\n",
913 n_deleted
, clo_max_snapshots
);
914 for (i
= 0; i
< next_snapshot_i
; i
++) {
915 VERB_snapshot(2, " post-cull", i
);
917 VERB(2, "New time interval = %lld (between snapshots %d and %d)\n",
918 min_timespan
, min_timespan_i
-1, min_timespan_i
);
924 static Time
get_time(void)
926 // Get current time, in whatever time unit we're using.
927 if (clo_time_unit
== TimeI
) {
928 return guest_instrs_executed
;
929 } else if (clo_time_unit
== TimeMS
) {
930 // Some stuff happens between the millisecond timer being initialised
931 // to zero and us taking our first snapshot. We determine that time
932 // gap so we can subtract it from all subsequent times so that our
933 // first snapshot is considered to be at t = 0ms. Unfortunately, a
934 // bunch of symbols get read after the first snapshot is taken but
935 // before the second one (which is triggered by the first allocation),
936 // so when the time-unit is 'ms' we always have a big gap between the
937 // first two snapshots. But at least users won't have to wonder why
938 // the first snapshot isn't at t=0.
939 static Bool is_first_get_time
= True
;
940 static Time start_time_ms
;
941 if (is_first_get_time
) {
942 start_time_ms
= VG_(read_millisecond_timer
)();
943 is_first_get_time
= False
;
946 return VG_(read_millisecond_timer
)() - start_time_ms
;
948 } else if (clo_time_unit
== TimeB
) {
949 return total_allocs_deallocs_szB
;
951 tl_assert2(0, "bad --time-unit value");
955 // Take a snapshot, and only that -- decisions on whether to take a
956 // snapshot, or what kind of snapshot, are made elsewhere.
957 // Nb: we call the arg "my_time" because "time" shadows a global declaration
958 // in /usr/include/time.h on Darwin.
960 take_snapshot(Snapshot
* snapshot
, SnapshotKind kind
, Time my_time
,
963 tl_assert(!is_snapshot_in_use(snapshot
));
964 if (!clo_pages_as_heap
) {
965 tl_assert(have_started_executing_code
);
968 // Heap and heap admin.
970 snapshot
->heap_szB
= heap_szB
;
972 snapshot
->xt
= VG_(XT_snapshot
)(heap_xt
);
974 snapshot
->heap_extra_szB
= heap_extra_szB
;
979 snapshot
->stacks_szB
= stacks_szB
;
983 snapshot
->kind
= kind
;
984 snapshot
->time
= my_time
;
985 sanity_check_snapshot(snapshot
);
988 if (Peak
== kind
) n_peak_snapshots
++;
989 if (is_detailed
) n_detailed_snapshots
++;
994 // Take a snapshot, if it's time, or if we've hit a peak.
996 maybe_take_snapshot(SnapshotKind kind
, const HChar
* what
)
998 // 'min_time_interval' is the minimum time interval between snapshots.
999 // If we try to take a snapshot and less than this much time has passed,
1000 // we don't take it. It gets larger as the program runs longer. It's
1001 // initialised to zero so that we begin by taking snapshots as quickly as
1003 static Time min_time_interval
= 0;
1004 // Zero allows startup snapshot.
1005 static Time earliest_possible_time_of_next_snapshot
= 0;
1006 static Int n_snapshots_since_last_detailed
= 0;
1007 static Int n_skipped_snapshots_since_last_snapshot
= 0;
1011 // Nb: we call this variable "my_time" because "time" shadows a global
1012 // declaration in /usr/include/time.h on Darwin.
1013 Time my_time
= get_time();
1017 // Only do a snapshot if it's time.
1018 if (my_time
< earliest_possible_time_of_next_snapshot
) {
1019 n_skipped_snapshots
++;
1020 n_skipped_snapshots_since_last_snapshot
++;
1023 is_detailed
= (clo_detailed_freq
-1 == n_snapshots_since_last_detailed
);
1027 // Because we're about to do a deallocation, we're coming down from a
1028 // local peak. If it is (a) actually a global peak, and (b) a certain
1029 // amount bigger than the previous peak, then we take a peak snapshot.
1030 // By not taking a snapshot for every peak, we save a lot of effort --
1031 // because many peaks remain peak only for a short time.
1032 SizeT total_szB
= heap_szB
+ heap_extra_szB
+ stacks_szB
;
1033 SizeT excess_szB_for_new_peak
=
1034 (SizeT
)((peak_snapshot_total_szB
* clo_peak_inaccuracy
) / 100);
1035 if (total_szB
<= peak_snapshot_total_szB
+ excess_szB_for_new_peak
) {
1043 tl_assert2(0, "maybe_take_snapshot: unrecognised snapshot kind");
1046 // Take the snapshot.
1047 snapshot
= & snapshots
[next_snapshot_i
];
1048 take_snapshot(snapshot
, kind
, my_time
, is_detailed
);
1050 // Record if it was detailed.
1052 n_snapshots_since_last_detailed
= 0;
1054 n_snapshots_since_last_detailed
++;
1057 // Update peak data, if it's a Peak snapshot.
1059 Int i
, number_of_peaks_snapshots_found
= 0;
1061 // Sanity check the size, then update our recorded peak.
1062 SizeT snapshot_total_szB
=
1063 snapshot
->heap_szB
+ snapshot
->heap_extra_szB
+ snapshot
->stacks_szB
;
1064 tl_assert2(snapshot_total_szB
> peak_snapshot_total_szB
,
1065 "%ld, %ld\n", snapshot_total_szB
, peak_snapshot_total_szB
);
1066 peak_snapshot_total_szB
= snapshot_total_szB
;
1068 // Find the old peak snapshot, if it exists, and mark it as normal.
1069 for (i
= 0; i
< next_snapshot_i
; i
++) {
1070 if (Peak
== snapshots
[i
].kind
) {
1071 snapshots
[i
].kind
= Normal
;
1072 number_of_peaks_snapshots_found
++;
1075 tl_assert(number_of_peaks_snapshots_found
<= 1);
1078 // Finish up verbosity and stats stuff.
1079 if (n_skipped_snapshots_since_last_snapshot
> 0) {
1080 VERB(2, " (skipped %d snapshot%s)\n",
1081 n_skipped_snapshots_since_last_snapshot
,
1082 ( 1 == n_skipped_snapshots_since_last_snapshot
? "" : "s") );
1084 VERB_snapshot(2, what
, next_snapshot_i
);
1085 n_skipped_snapshots_since_last_snapshot
= 0;
1087 // Cull the entries, if our snapshot table is full.
1089 if (clo_max_snapshots
== next_snapshot_i
) {
1090 min_time_interval
= cull_snapshots();
1093 // Work out the earliest time when the next snapshot can happen.
1094 earliest_possible_time_of_next_snapshot
= my_time
+ min_time_interval
;
1098 //------------------------------------------------------------//
1099 //--- Sanity checking ---//
1100 //------------------------------------------------------------//
1102 static Bool
ms_cheap_sanity_check ( void )
1104 return True
; // Nothing useful we can cheaply check.
1107 static Bool
ms_expensive_sanity_check ( void )
1110 sanity_check_snapshots_array();
1115 //------------------------------------------------------------//
1116 //--- Heap management ---//
1117 //------------------------------------------------------------//
1119 // Metadata for heap blocks. Each one contains an Xecu,
1120 // which identifies the XTree ec at which it was allocated. From
1121 // HP_Chunks, XTree ec 'space' field is incremented (at allocation) and
1122 // decremented (at deallocation).
1124 // Nb: first two fields must match core's VgHashNode.
1127 struct _HP_Chunk
* next
;
1128 Addr data
; // Ptr to actual block
1129 SizeT req_szB
; // Size requested
1130 SizeT slop_szB
; // Extra bytes given above those requested
1131 Xecu where
; // Where allocated; XTree xecu from heap_xt
1135 /* Pool allocator for HP_Chunk. */
1136 static PoolAlloc
*HP_chunk_poolalloc
= NULL
;
1138 static VgHashTable
*malloc_list
= NULL
; // HP_Chunks
1140 static void update_alloc_stats(SSizeT szB_delta
)
1142 // Update total_allocs_deallocs_szB.
1143 if (szB_delta
< 0) szB_delta
= -szB_delta
;
1144 total_allocs_deallocs_szB
+= szB_delta
;
1147 static void update_heap_stats(SSizeT heap_szB_delta
, Int heap_extra_szB_delta
)
1149 if (heap_szB_delta
< 0)
1150 tl_assert(heap_szB
>= -heap_szB_delta
);
1151 if (heap_extra_szB_delta
< 0)
1152 tl_assert(heap_extra_szB
>= -heap_extra_szB_delta
);
1154 heap_extra_szB
+= heap_extra_szB_delta
;
1155 heap_szB
+= heap_szB_delta
;
1157 update_alloc_stats(heap_szB_delta
+ heap_extra_szB_delta
);
1161 void* record_block( ThreadId tid
, void* p
, SizeT req_szB
, SizeT slop_szB
,
1162 Bool exclude_first_entry
, Bool maybe_snapshot
)
1164 // Make new HP_Chunk node, add to malloc_list
1165 HP_Chunk
* hc
= VG_(allocEltPA
)(HP_chunk_poolalloc
);
1166 hc
->req_szB
= req_szB
;
1167 hc
->slop_szB
= slop_szB
;
1170 VG_(HT_add_node
)(malloc_list
, hc
);
1173 VERB(3, "<<< record_block (%lu, %lu)\n", req_szB
, slop_szB
);
1175 hc
->where
= add_heap_xt( tid
, req_szB
, exclude_first_entry
);
1177 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1178 // Update statistics.
1181 // Update heap stats.
1182 update_heap_stats(req_szB
, clo_heap_admin
+ slop_szB
);
1184 // Maybe take a snapshot.
1185 if (maybe_snapshot
) {
1186 maybe_take_snapshot(Normal
, " alloc");
1190 // Ignored allocation.
1191 n_ignored_heap_allocs
++;
1193 VERB(3, "(ignored)\n");
1203 void* alloc_and_record_block ( ThreadId tid
, SizeT req_szB
, SizeT req_alignB
,
1206 SizeT actual_szB
, slop_szB
;
1209 if ((SSizeT
)req_szB
< 0) return NULL
;
1211 // Allocate and zero if necessary.
1212 p
= VG_(cli_malloc
)( req_alignB
, req_szB
);
1216 if (is_zeroed
) VG_(memset
)(p
, 0, req_szB
);
1217 actual_szB
= VG_(cli_malloc_usable_size
)(p
);
1218 tl_assert(actual_szB
>= req_szB
);
1219 slop_szB
= actual_szB
- req_szB
;
1222 record_block(tid
, p
, req_szB
, slop_szB
, /*exclude_first_entry*/True
,
1223 /*maybe_snapshot*/True
);
1229 void unrecord_block ( void* p
, Bool maybe_snapshot
, Bool exclude_first_entry
)
1231 // Remove HP_Chunk from malloc_list
1232 HP_Chunk
* hc
= VG_(HT_remove
)(malloc_list
, (UWord
)p
);
1234 return; // must have been a bogus free()
1238 VERB(3, "<<< unrecord_block\n");
1240 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1241 // Update statistics.
1244 // Maybe take a peak snapshot, since it's a deallocation.
1245 if (maybe_snapshot
) {
1246 maybe_take_snapshot(Peak
, "de-PEAK");
1249 // Update heap stats.
1250 update_heap_stats(-hc
->req_szB
, -clo_heap_admin
- hc
->slop_szB
);
1253 sub_heap_xt(hc
->where
, hc
->req_szB
, exclude_first_entry
);
1255 // Maybe take a snapshot.
1256 if (maybe_snapshot
) {
1257 maybe_take_snapshot(Normal
, "dealloc");
1261 n_ignored_heap_frees
++;
1263 VERB(3, "(ignored)\n");
1266 VERB(3, ">>> (-%lu, -%lu)\n", hc
->req_szB
, hc
->slop_szB
);
1269 // Actually free the chunk, and the heap block (if necessary)
1270 VG_(freeEltPA
) (HP_chunk_poolalloc
, hc
); hc
= NULL
;
1273 // Nb: --ignore-fn is tricky for realloc. If the block's original alloc was
1274 // ignored, but the realloc is not requested to be ignored, and we are
1275 // shrinking the block, then we have to ignore the realloc -- otherwise we
1276 // could end up with negative heap sizes. This isn't a danger if we are
1277 // growing such a block, but for consistency (it also simplifies things) we
1278 // ignore such reallocs as well.
1279 // PW Nov 2016 xtree work: why can't we just consider that a realloc of an
1280 // ignored alloc is just a new alloc (i.e. do not remove the old sz from the
1281 // stats). Then everything would be fine, and a non ignored realloc would be
1282 // counted properly.
1284 void* realloc_block ( ThreadId tid
, void* p_old
, SizeT new_req_szB
)
1288 SizeT old_req_szB
, old_slop_szB
, new_slop_szB
, new_actual_szB
;
1290 Bool is_ignored
= False
;
1292 if (p_old
== NULL
) {
1293 return alloc_and_record_block( tid
, new_req_szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1296 if (new_req_szB
== 0U) {
1297 if (VG_(clo_realloc_zero_bytes_frees
) == True
) {
1299 unrecord_block(p_old
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1300 VG_(cli_free
)(p_old
);
1306 // Remove the old block
1307 hc
= VG_(HT_remove
)(malloc_list
, (UWord
)p_old
);
1309 return NULL
; // must have been a bogus realloc()
1312 old_req_szB
= hc
->req_szB
;
1313 old_slop_szB
= hc
->slop_szB
;
1315 tl_assert(!clo_pages_as_heap
); // Shouldn't be here if --pages-as-heap=yes.
1317 VERB(3, "<<< realloc_block (%lu)\n", new_req_szB
);
1319 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1320 // Update statistics.
1323 // Maybe take a peak snapshot, if it's (effectively) a deallocation.
1324 if (new_req_szB
< old_req_szB
) {
1325 maybe_take_snapshot(Peak
, "re-PEAK");
1328 // The original malloc was ignored, so we have to ignore the
1334 // Actually do the allocation, if necessary.
1335 if (new_req_szB
<= old_req_szB
+ old_slop_szB
) {
1336 // New size is smaller or same; block not moved.
1338 new_slop_szB
= old_slop_szB
+ (old_req_szB
- new_req_szB
);
1341 // New size is bigger; make new block, copy shared contents, free old.
1342 p_new
= VG_(cli_malloc
)(VG_(clo_alignment
), new_req_szB
);
1344 // Nb: if realloc fails, NULL is returned but the old block is not
1345 // touched. What an awful function.
1348 VG_(memcpy
)(p_new
, p_old
, old_req_szB
+ old_slop_szB
);
1349 VG_(cli_free
)(p_old
);
1350 new_actual_szB
= VG_(cli_malloc_usable_size
)(p_new
);
1351 tl_assert(new_actual_szB
>= new_req_szB
);
1352 new_slop_szB
= new_actual_szB
- new_req_szB
;
1357 hc
->data
= (Addr
)p_new
;
1358 hc
->req_szB
= new_req_szB
;
1359 hc
->slop_szB
= new_slop_szB
;
1360 old_where
= hc
->where
;
1365 hc
->where
= add_heap_xt( tid
, new_req_szB
,
1366 /*exclude_first_entry*/True
);
1367 if (!is_ignored
&& VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0) {
1368 sub_heap_xt(old_where
, old_req_szB
, /*exclude_first_entry*/True
);
1370 // The realloc itself is ignored.
1373 /* XTREE??? hack to have something compatible with pre
1374 m_xtree massif: if the previous alloc/realloc was
1375 ignored, and this one is not ignored, then keep the
1376 previous where, to continue marking this memory as
1378 if (VG_(XT_n_ips_sel
)(heap_xt
, hc
->where
) > 0
1379 && VG_(XT_n_ips_sel
)(heap_xt
, old_where
) == 0)
1380 hc
->where
= old_where
;
1382 // Update statistics.
1383 n_ignored_heap_reallocs
++;
1388 // Now insert the new hc (with a possibly new 'data' field) into
1389 // malloc_list. If this realloc() did not increase the memory size, we
1390 // will have removed and then re-added hc unnecessarily. But that's ok
1391 // because shrinking a block with realloc() is (presumably) much rarer
1392 // than growing it, and this way simplifies the growing case.
1393 VG_(HT_add_node
)(malloc_list
, hc
);
1397 // Update heap stats.
1398 update_heap_stats(new_req_szB
- old_req_szB
,
1399 new_slop_szB
- old_slop_szB
);
1401 // Maybe take a snapshot.
1402 maybe_take_snapshot(Normal
, "realloc");
1405 VERB(3, "(ignored)\n");
1408 VERB(3, ">>> (%ld, %ld)\n",
1409 (SSizeT
)(new_req_szB
- old_req_szB
),
1410 (SSizeT
)(new_slop_szB
- old_slop_szB
));
1417 //------------------------------------------------------------//
1418 //--- malloc() et al replacement wrappers ---//
1419 //------------------------------------------------------------//
1421 static void* ms_malloc ( ThreadId tid
, SizeT szB
)
1423 return alloc_and_record_block( tid
, szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1426 static void* ms___builtin_new ( ThreadId tid
, SizeT szB
)
1428 return alloc_and_record_block( tid
, szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1431 static void* ms___builtin_new_aligned ( ThreadId tid
, SizeT szB
, SizeT alignB
)
1433 return alloc_and_record_block( tid
, szB
, alignB
, /*is_zeroed*/False
);
1436 static void* ms___builtin_vec_new ( ThreadId tid
, SizeT szB
)
1438 return alloc_and_record_block( tid
, szB
, VG_(clo_alignment
), /*is_zeroed*/False
);
1441 static void* ms___builtin_vec_new_aligned ( ThreadId tid
, SizeT szB
, SizeT alignB
)
1443 return alloc_and_record_block( tid
, szB
, alignB
, /*is_zeroed*/False
);
1446 static void* ms_calloc ( ThreadId tid
, SizeT m
, SizeT szB
)
1448 return alloc_and_record_block( tid
, m
*szB
, VG_(clo_alignment
), /*is_zeroed*/True
);
1451 static void *ms_memalign ( ThreadId tid
, SizeT alignB
, SizeT szB
)
1453 return alloc_and_record_block( tid
, szB
, alignB
, False
);
1456 static void ms_free ( ThreadId tid
__attribute__((unused
)), void* p
)
1458 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1462 static void ms___builtin_delete ( ThreadId tid
, void* p
)
1464 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1468 static void ms___builtin_delete_aligned ( ThreadId tid
, void* p
, SizeT align
)
1470 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1474 static void ms___builtin_vec_delete ( ThreadId tid
, void* p
)
1476 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1480 static void ms___builtin_vec_delete_aligned ( ThreadId tid
, void* p
, SizeT align
)
1482 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/True
);
1486 static void* ms_realloc ( ThreadId tid
, void* p_old
, SizeT new_szB
)
1488 return realloc_block(tid
, p_old
, new_szB
);
1491 static SizeT
ms_malloc_usable_size ( ThreadId tid
, void* p
)
1493 HP_Chunk
* hc
= VG_(HT_lookup
)( malloc_list
, (UWord
)p
);
1495 return ( hc
? hc
->req_szB
+ hc
->slop_szB
: 0 );
1498 //------------------------------------------------------------//
1499 //--- Page handling ---//
1500 //------------------------------------------------------------//
1503 void ms_record_page_mem ( Addr a
, SizeT len
)
1505 ThreadId tid
= VG_(get_running_tid
)();
1507 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1508 tl_assert(len
>= VKI_PAGE_SIZE
);
1509 // Record the first N-1 pages as blocks, but don't do any snapshots.
1510 for (end
= a
+ len
- VKI_PAGE_SIZE
; a
< end
; a
+= VKI_PAGE_SIZE
) {
1511 record_block( tid
, (void*)a
, VKI_PAGE_SIZE
, /*slop_szB*/0,
1512 /*exclude_first_entry*/False
, /*maybe_snapshot*/False
);
1514 // Record the last page as a block, and maybe do a snapshot afterwards.
1515 record_block( tid
, (void*)a
, VKI_PAGE_SIZE
, /*slop_szB*/0,
1516 /*exclude_first_entry*/False
, /*maybe_snapshot*/True
);
1520 void ms_unrecord_page_mem( Addr a
, SizeT len
)
1523 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1524 tl_assert(len
>= VKI_PAGE_SIZE
);
1525 // Unrecord the first page. This might be the peak, so do a snapshot.
1526 unrecord_block((void*)a
, /*maybe_snapshot*/True
,
1527 /*exclude_first_entry*/False
);
1529 // Then unrecord the remaining pages, but without snapshots.
1530 for (end
= a
+ len
- VKI_PAGE_SIZE
; a
< end
; a
+= VKI_PAGE_SIZE
) {
1531 unrecord_block((void*)a
, /*maybe_snapshot*/False
,
1532 /*exclude_first_entry*/False
);
1536 //------------------------------------------------------------//
1539 void ms_new_mem_mmap ( Addr a
, SizeT len
,
1540 Bool rr
, Bool ww
, Bool xx
, ULong di_handle
)
1542 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1543 ms_record_page_mem(a
, len
);
1547 void ms_new_mem_startup( Addr a
, SizeT len
,
1548 Bool rr
, Bool ww
, Bool xx
, ULong di_handle
)
1550 // startup maps are always be page-sized, except the trampoline page is
1551 // marked by the core as only being the size of the trampoline itself,
1552 // which is something like 57 bytes. Round it up to page size.
1553 len
= VG_PGROUNDUP(len
);
1554 ms_record_page_mem(a
, len
);
1558 void ms_new_mem_brk ( Addr a
, SizeT len
, ThreadId tid
)
1560 // brk limit is not necessarily aligned on a page boundary.
1561 // If new memory being brk-ed implies to allocate a new page,
1562 // then call ms_record_page_mem with page aligned parameters
1563 // otherwise just ignore.
1564 Addr old_bottom_page
= VG_PGROUNDDN(a
- 1);
1565 Addr new_top_page
= VG_PGROUNDDN(a
+ len
- 1);
1566 if (old_bottom_page
!= new_top_page
)
1567 ms_record_page_mem(VG_PGROUNDDN(a
),
1568 (new_top_page
- old_bottom_page
));
1572 void ms_copy_mem_remap( Addr from
, Addr to
, SizeT len
)
1574 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1575 ms_unrecord_page_mem(from
, len
);
1576 ms_record_page_mem(to
, len
);
1580 void ms_die_mem_munmap( Addr a
, SizeT len
)
1582 tl_assert(VG_IS_PAGE_ALIGNED(len
));
1583 ms_unrecord_page_mem(a
, len
);
1587 void ms_die_mem_brk( Addr a
, SizeT len
)
1589 // Call ms_unrecord_page_mem only if one or more pages are de-allocated.
1590 // See ms_new_mem_brk for more details.
1591 Addr new_bottom_page
= VG_PGROUNDDN(a
- 1);
1592 Addr old_top_page
= VG_PGROUNDDN(a
+ len
- 1);
1593 if (old_top_page
!= new_bottom_page
)
1594 ms_unrecord_page_mem(VG_PGROUNDDN(a
),
1595 (old_top_page
- new_bottom_page
));
1599 //------------------------------------------------------------//
1601 //------------------------------------------------------------//
1603 // We really want the inlining to occur...
1604 #define INLINE inline __attribute__((always_inline))
1606 static void update_stack_stats(SSizeT stack_szB_delta
)
1608 if (stack_szB_delta
< 0) tl_assert(stacks_szB
>= -stack_szB_delta
);
1609 stacks_szB
+= stack_szB_delta
;
1611 update_alloc_stats(stack_szB_delta
);
1614 static INLINE
void new_mem_stack_2(SizeT len
, const HChar
* what
)
1616 if (have_started_executing_code
) {
1617 VERB(3, "<<< new_mem_stack (%lu)\n", len
);
1619 update_stack_stats(len
);
1620 maybe_take_snapshot(Normal
, what
);
1625 static INLINE
void die_mem_stack_2(SizeT len
, const HChar
* what
)
1627 if (have_started_executing_code
) {
1628 VERB(3, "<<< die_mem_stack (-%lu)\n", len
);
1630 maybe_take_snapshot(Peak
, "stkPEAK");
1631 update_stack_stats(-len
);
1632 maybe_take_snapshot(Normal
, what
);
1637 static void new_mem_stack(Addr a
, SizeT len
)
1639 new_mem_stack_2(len
, "stk-new");
1642 static void die_mem_stack(Addr a
, SizeT len
)
1644 die_mem_stack_2(len
, "stk-die");
1647 static void new_mem_stack_signal(Addr a
, SizeT len
, ThreadId tid
)
1649 new_mem_stack_2(len
, "sig-new");
1652 static void die_mem_stack_signal(Addr a
, SizeT len
)
1654 die_mem_stack_2(len
, "sig-die");
1658 //------------------------------------------------------------//
1659 //--- Client Requests ---//
1660 //------------------------------------------------------------//
1662 static void print_monitor_help ( void )
1666 "massif monitor commands:\n"
1667 " snapshot [<filename>]\n"
1668 " detailed_snapshot [<filename>]\n"
1669 " takes a snapshot (or a detailed snapshot)\n"
1670 " and saves it in <filename>\n"
1671 " default <filename> is massif.vgdb.out\n"
1672 " all_snapshots [<filename>]\n"
1673 " saves all snapshot(s) taken so far in <filename>\n"
1674 " default <filename> is massif.vgdb.out\n"
1675 " xtmemory [<filename>]\n"
1676 " dump xtree memory profile in <filename> (default xtmemory.kcg.%%p.%%n)\n"
1681 /* Forward declaration.
1682 return True if request recognised, False otherwise */
1683 static Bool
handle_gdb_monitor_command (ThreadId tid
, HChar
*req
);
1684 static Bool
ms_handle_client_request ( ThreadId tid
, UWord
* argv
, UWord
* ret
)
1687 case VG_USERREQ__MALLOCLIKE_BLOCK
: {
1688 void* p
= (void*)argv
[1];
1689 SizeT szB
= argv
[2];
1690 record_block( tid
, p
, szB
, /*slop_szB*/0, /*exclude_first_entry*/False
,
1691 /*maybe_snapshot*/True
);
1695 case VG_USERREQ__RESIZEINPLACE_BLOCK
: {
1696 void* p
= (void*)argv
[1];
1697 SizeT newSizeB
= argv
[3];
1699 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/False
);
1700 record_block(tid
, p
, newSizeB
, /*slop_szB*/0,
1701 /*exclude_first_entry*/False
, /*maybe_snapshot*/True
);
1704 case VG_USERREQ__FREELIKE_BLOCK
: {
1705 void* p
= (void*)argv
[1];
1706 unrecord_block(p
, /*maybe_snapshot*/True
, /*exclude_first_entry*/False
);
1710 case VG_USERREQ__GDB_MONITOR_COMMAND
: {
1711 Bool handled
= handle_gdb_monitor_command (tid
, (HChar
*)argv
[1]);
1725 //------------------------------------------------------------//
1726 //--- Instrumentation ---//
1727 //------------------------------------------------------------//
1729 static void add_counter_update(IRSB
* sbOut
, Int n
)
1731 #if defined(VG_BIGENDIAN)
1732 # define END Iend_BE
1733 #elif defined(VG_LITTLEENDIAN)
1734 # define END Iend_LE
1736 # error "Unknown endianness"
1738 // Add code to increment 'guest_instrs_executed' by 'n', like this:
1739 // WrTmp(t1, Load64(&guest_instrs_executed))
1740 // WrTmp(t2, Add64(RdTmp(t1), Const(n)))
1741 // Store(&guest_instrs_executed, t2)
1742 IRTemp t1
= newIRTemp(sbOut
->tyenv
, Ity_I64
);
1743 IRTemp t2
= newIRTemp(sbOut
->tyenv
, Ity_I64
);
1744 IRExpr
* counter_addr
= mkIRExpr_HWord( (HWord
)&guest_instrs_executed
);
1746 IRStmt
* st1
= IRStmt_WrTmp(t1
, IRExpr_Load(END
, Ity_I64
, counter_addr
));
1749 IRExpr_Binop(Iop_Add64
, IRExpr_RdTmp(t1
),
1750 IRExpr_Const(IRConst_U64(n
))));
1751 IRStmt
* st3
= IRStmt_Store(END
, counter_addr
, IRExpr_RdTmp(t2
));
1753 addStmtToIRSB( sbOut
, st1
);
1754 addStmtToIRSB( sbOut
, st2
);
1755 addStmtToIRSB( sbOut
, st3
);
1758 static IRSB
* ms_instrument2( IRSB
* sbIn
)
1763 // We increment the instruction count in two places:
1764 // - just before any Ist_Exit statements;
1765 // - just before the IRSB's end.
1766 // In the former case, we zero 'n' and then continue instrumenting.
1768 sbOut
= deepCopyIRSBExceptStmts(sbIn
);
1770 for (i
= 0; i
< sbIn
->stmts_used
; i
++) {
1771 IRStmt
* st
= sbIn
->stmts
[i
];
1773 if (!st
|| st
->tag
== Ist_NoOp
) continue;
1775 if (st
->tag
== Ist_IMark
) {
1777 } else if (st
->tag
== Ist_Exit
) {
1779 // Add an increment before the Exit statement, then reset 'n'.
1780 add_counter_update(sbOut
, n
);
1784 addStmtToIRSB( sbOut
, st
);
1788 // Add an increment before the SB end.
1789 add_counter_update(sbOut
, n
);
1795 IRSB
* ms_instrument ( VgCallbackClosure
* closure
,
1797 const VexGuestLayout
* layout
,
1798 const VexGuestExtents
* vge
,
1799 const VexArchInfo
* archinfo_host
,
1800 IRType gWordTy
, IRType hWordTy
)
1802 if (! have_started_executing_code
) {
1803 // Do an initial sample to guarantee that we have at least one.
1804 // We use 'maybe_take_snapshot' instead of 'take_snapshot' to ensure
1805 // 'maybe_take_snapshot's internal static variables are initialised.
1806 have_started_executing_code
= True
;
1807 maybe_take_snapshot(Normal
, "startup");
1810 if (clo_time_unit
== TimeI
) { return ms_instrument2(sbIn
); }
1811 else if (clo_time_unit
== TimeMS
) { return sbIn
; }
1812 else if (clo_time_unit
== TimeB
) { return sbIn
; }
1813 else { tl_assert2(0, "bad --time-unit value"); }
1817 //------------------------------------------------------------//
1818 //--- Writing snapshots ---//
1819 //------------------------------------------------------------//
1821 static void pp_snapshot(MsFile
*fp
, Snapshot
* snapshot
, Int snapshot_n
)
1823 const Massif_Header header
= (Massif_Header
) {
1824 .snapshot_n
= snapshot_n
,
1825 .time
= snapshot
->time
,
1826 .sz_B
= snapshot
->heap_szB
,
1827 .extra_B
= snapshot
->heap_extra_szB
,
1828 .stacks_B
= snapshot
->stacks_szB
,
1829 .detailed
= is_detailed_snapshot(snapshot
),
1830 .peak
= Peak
== snapshot
->kind
,
1831 .top_node_desc
= clo_pages_as_heap
?
1832 "(page allocation syscalls) mmap/mremap/brk, --alloc-fns, etc."
1833 : "(heap allocation functions) malloc/new/new[], --alloc-fns, etc.",
1834 .sig_threshold
= clo_threshold
1837 sanity_check_snapshot(snapshot
);
1839 VG_(XT_massif_print
)(fp
, snapshot
->xt
, &header
, alloc_szB
);
1842 static void write_snapshots_to_file(const HChar
* massif_out_file
,
1843 Snapshot snapshots_array
[],
1849 fp
= VG_(XT_massif_open
)(massif_out_file
,
1852 TimeUnit_to_string(clo_time_unit
));
1854 return; // Error reported by VG_(XT_massif_open)
1856 for (i
= 0; i
< nr_elements
; i
++) {
1857 Snapshot
* snapshot
= & snapshots_array
[i
];
1858 pp_snapshot(fp
, snapshot
, i
); // Detailed snapshot!
1860 VG_(XT_massif_close
) (fp
);
1863 static void write_snapshots_array_to_file(void)
1865 // Setup output filename. Nb: it's important to do this now, ie. as late
1866 // as possible. If we do it at start-up and the program forks and the
1867 // output file format string contains a %p (pid) specifier, both the
1868 // parent and child will incorrectly write to the same file; this
1869 // happened in 3.3.0.
1870 HChar
* massif_out_file
=
1871 VG_(expand_file_name
)("--massif-out-file", clo_massif_out_file
);
1872 write_snapshots_to_file (massif_out_file
, snapshots
, next_snapshot_i
);
1873 VG_(free
)(massif_out_file
);
1876 static void handle_snapshot_monitor_command (const HChar
*filename
,
1881 if (!clo_pages_as_heap
&& !have_started_executing_code
) {
1882 // See comments of variable have_started_executing_code.
1884 ("error: cannot take snapshot before execution has started\n");
1888 clear_snapshot(&snapshot
, /* do_sanity_check */ False
);
1889 take_snapshot(&snapshot
, Normal
, get_time(), detailed
);
1890 write_snapshots_to_file ((filename
== NULL
) ?
1891 "massif.vgdb.out" : filename
,
1894 delete_snapshot(&snapshot
);
1897 static void handle_all_snapshots_monitor_command (const HChar
*filename
)
1899 if (!clo_pages_as_heap
&& !have_started_executing_code
) {
1900 // See comments of variable have_started_executing_code.
1902 ("error: cannot take snapshot before execution has started\n");
1906 write_snapshots_to_file ((filename
== NULL
) ?
1907 "massif.vgdb.out" : filename
,
1908 snapshots
, next_snapshot_i
);
1911 static void xtmemory_report_next_block(XT_Allocs
* xta
, ExeContext
** ec_alloc
)
1913 const HP_Chunk
* hc
= VG_(HT_Next
)(malloc_list
);
1915 xta
->nbytes
= hc
->req_szB
;
1917 *ec_alloc
= VG_(XT_get_ec_from_xecu
)(heap_xt
, hc
->where
);
1921 static void ms_xtmemory_report ( const HChar
* filename
, Bool fini
)
1923 // Make xtmemory_report_next_block ready to be called.
1924 VG_(HT_ResetIter
)(malloc_list
);
1925 VG_(XTMemory_report
)(filename
, fini
, xtmemory_report_next_block
,
1926 VG_(XT_filter_maybe_below_main
));
1927 /* As massif already filters one top function, use as filter
1928 VG_(XT_filter_maybe_below_main). */
1931 static Bool
handle_gdb_monitor_command (ThreadId tid
, HChar
*req
)
1934 HChar s
[VG_(strlen
)(req
) + 1]; /* copy for strtok_r */
1937 VG_(strcpy
) (s
, req
);
1939 wcmd
= VG_(strtok_r
) (s
, " ", &ssaveptr
);
1940 switch (VG_(keyword_id
) ("help snapshot detailed_snapshot all_snapshots"
1942 wcmd
, kwd_report_duplicated_matches
)) {
1943 case -2: /* multiple matches */
1945 case -1: /* not found */
1948 print_monitor_help();
1950 case 1: { /* snapshot */
1952 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1953 handle_snapshot_monitor_command (filename
, False
/* detailed */);
1956 case 2: { /* detailed_snapshot */
1958 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1959 handle_snapshot_monitor_command (filename
, True
/* detailed */);
1962 case 3: { /* all_snapshots */
1964 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1965 handle_all_snapshots_monitor_command (filename
);
1968 case 4: { /* xtmemory */
1970 filename
= VG_(strtok_r
) (NULL
, " ", &ssaveptr
);
1971 ms_xtmemory_report (filename
, False
);
1980 static void ms_print_stats (void)
1982 #define STATS(format, args...) \
1983 VG_(dmsg)("Massif: " format, ##args)
1985 STATS("heap allocs: %u\n", n_heap_allocs
);
1986 STATS("heap reallocs: %u\n", n_heap_reallocs
);
1987 STATS("heap frees: %u\n", n_heap_frees
);
1988 STATS("ignored heap allocs: %u\n", n_ignored_heap_allocs
);
1989 STATS("ignored heap frees: %u\n", n_ignored_heap_frees
);
1990 STATS("ignored heap reallocs: %u\n", n_ignored_heap_reallocs
);
1991 STATS("stack allocs: %u\n", n_stack_allocs
);
1992 STATS("skipped snapshots: %u\n", n_skipped_snapshots
);
1993 STATS("real snapshots: %u\n", n_real_snapshots
);
1994 STATS("detailed snapshots: %u\n", n_detailed_snapshots
);
1995 STATS("peak snapshots: %u\n", n_peak_snapshots
);
1996 STATS("cullings: %u\n", n_cullings
);
2001 //------------------------------------------------------------//
2002 //--- Finalisation ---//
2003 //------------------------------------------------------------//
2005 static void ms_fini(Int exit_status
)
2007 ms_xtmemory_report(VG_(clo_xtree_memory_file
), True
);
2010 write_snapshots_array_to_file();
2017 //------------------------------------------------------------//
2018 //--- Initialisation ---//
2019 //------------------------------------------------------------//
2021 static void ms_post_clo_init(void)
2024 HChar
* LD_PRELOAD_val
;
2026 /* We will record execontext up to clo_depth + overestimate and
2027 we will store this as ec => we need to increase the backtrace size
2028 if smaller than what we will store. */
2029 if (VG_(clo_backtrace_size
) < clo_depth
+ MAX_OVERESTIMATE
)
2030 VG_(clo_backtrace_size
) = clo_depth
+ MAX_OVERESTIMATE
;
2033 if (clo_pages_as_heap
) {
2035 VG_(fmsg_bad_option
)("--pages-as-heap=yes",
2036 "Cannot be used together with --stacks=yes");
2040 clo_pages_as_heap
= False
;
2043 // If --pages-as-heap=yes we don't want malloc replacement to occur. So we
2044 // disable vgpreload_massif-$PLATFORM.so by removing it from LD_PRELOAD (or
2045 // platform-equivalent). This is a bit of a hack, but LD_PRELOAD is setup
2046 // well before tool initialisation, so this seems the best way to do it.
2047 if (clo_pages_as_heap
) {
2051 clo_heap_admin
= 0; // No heap admin on pages.
2053 LD_PRELOAD_val
= VG_(getenv
)( VG_(LD_PRELOAD_var_name
) );
2054 tl_assert(LD_PRELOAD_val
);
2056 VERB(2, "clo_pages_as_heap orig LD_PRELOAD '%s'\n", LD_PRELOAD_val
);
2058 // Make sure the vgpreload_core-$PLATFORM entry is there, for sanity.
2059 s1
= VG_(strstr
)(LD_PRELOAD_val
, "vgpreload_core");
2062 // Now find the vgpreload_massif-$PLATFORM entry.
2063 s1
= VG_(strstr
)(LD_PRELOAD_val
, "vgpreload_massif");
2067 // Position s1 on the previous ':', which must be there because
2068 // of the preceding vgpreload_core-$PLATFORM entry.
2069 for (; *s1
!= ':'; s1
--)
2072 // Position s2 on the next ':' or \0
2073 for (; *s2
!= ':' && *s2
!= '\0'; s2
++)
2076 // Move all characters from s2 to s1
2077 while ((*s1
++ = *s2
++))
2080 VERB(2, "clo_pages_as_heap cleaned LD_PRELOAD '%s'\n", LD_PRELOAD_val
);
2083 // Print alloc-fns and ignore-fns, if necessary.
2084 if (VG_(clo_verbosity
) > 1) {
2085 VERB(1, "alloc-fns:\n");
2086 for (i
= 0; i
< VG_(sizeXA
)(alloc_fns
); i
++) {
2087 HChar
** fn_ptr
= VG_(indexXA
)(alloc_fns
, i
);
2088 VERB(1, " %s\n", *fn_ptr
);
2091 VERB(1, "ignore-fns:\n");
2092 if (0 == VG_(sizeXA
)(ignore_fns
)) {
2093 VERB(1, " <empty>\n");
2095 for (i
= 0; i
< VG_(sizeXA
)(ignore_fns
); i
++) {
2096 HChar
** fn_ptr
= VG_(indexXA
)(ignore_fns
, i
);
2097 VERB(1, " %d: %s\n", i
, *fn_ptr
);
2103 VG_(track_new_mem_stack
) ( new_mem_stack
);
2104 VG_(track_die_mem_stack
) ( die_mem_stack
);
2105 VG_(track_new_mem_stack_signal
) ( new_mem_stack_signal
);
2106 VG_(track_die_mem_stack_signal
) ( die_mem_stack_signal
);
2109 if (clo_pages_as_heap
) {
2110 VG_(track_new_mem_startup
) ( ms_new_mem_startup
);
2111 VG_(track_new_mem_brk
) ( ms_new_mem_brk
);
2112 VG_(track_new_mem_mmap
) ( ms_new_mem_mmap
);
2114 VG_(track_copy_mem_remap
) ( ms_copy_mem_remap
);
2116 VG_(track_die_mem_brk
) ( ms_die_mem_brk
);
2117 VG_(track_die_mem_munmap
) ( ms_die_mem_munmap
);
2120 // Initialise snapshot array, and sanity-check it.
2121 snapshots
= VG_(malloc
)("ms.main.mpoci.1",
2122 sizeof(Snapshot
) * clo_max_snapshots
);
2123 // We don't want to do snapshot sanity checks here, because they're
2124 // currently uninitialised.
2125 for (i
= 0; i
< clo_max_snapshots
; i
++) {
2126 clear_snapshot( & snapshots
[i
], /*do_sanity_check*/False
);
2128 sanity_check_snapshots_array();
2130 if (VG_(clo_xtree_memory
) == Vg_XTMemory_Full
)
2131 // Activate full xtree memory profiling.
2132 // As massif already filters one top function, use as filter
2133 // VG_(XT_filter_maybe_below_main).
2134 VG_(XTMemory_Full_init
)(VG_(XT_filter_maybe_below_main
));
2138 static void ms_pre_clo_init(void)
2140 VG_(details_name
) ("Massif");
2141 VG_(details_version
) (NULL
);
2142 VG_(details_description
) ("a heap profiler");
2143 VG_(details_copyright_author
)(
2144 "Copyright (C) 2003-2017, and GNU GPL'd, by Nicholas Nethercote");
2145 VG_(details_bug_reports_to
) (VG_BUGS_TO
);
2147 VG_(details_avg_translation_sizeB
) ( 330 );
2149 VG_(clo_vex_control
).iropt_register_updates_default
2150 = VG_(clo_px_file_backed
)
2151 = VexRegUpdSpAtMemAccess
; // overridable by the user.
2154 VG_(basic_tool_funcs
) (ms_post_clo_init
,
2159 VG_(needs_libc_freeres
)();
2160 VG_(needs_cxx_freeres
)();
2161 VG_(needs_command_line_options
)(ms_process_cmd_line_option
,
2163 ms_print_debug_usage
);
2164 VG_(needs_client_requests
) (ms_handle_client_request
);
2165 VG_(needs_sanity_checks
) (ms_cheap_sanity_check
,
2166 ms_expensive_sanity_check
);
2167 VG_(needs_print_stats
) (ms_print_stats
);
2168 VG_(needs_malloc_replacement
) (ms_malloc
,
2170 ms___builtin_new_aligned
,
2171 ms___builtin_vec_new
,
2172 ms___builtin_vec_new_aligned
,
2176 ms___builtin_delete
,
2177 ms___builtin_delete_aligned
,
2178 ms___builtin_vec_delete
,
2179 ms___builtin_vec_delete_aligned
,
2181 ms_malloc_usable_size
,
2185 HP_chunk_poolalloc
= VG_(newPA
)
2189 "massif MC_Chunk pool",
2191 malloc_list
= VG_(HT_construct
)( "Massif's malloc list" );
2194 heap_xt
= VG_(XT_create
)(VG_(malloc
),
2198 init_szB
, add_szB
, sub_szB
,
2201 // Initialise alloc_fns and ignore_fns.
2205 // Initialise args_for_massif.
2206 args_for_massif
= VG_(newXA
)(VG_(malloc
), "ms.main.mprci.1",
2207 VG_(free
), sizeof(HChar
*));
2210 VG_DETERMINE_INTERFACE_VERSION(ms_pre_clo_init
)
2212 //--------------------------------------------------------------------//
2214 //--------------------------------------------------------------------//