1 2 /*--------------------------------------------------------------------*/ 3 /*--- Support functions for xtree memory reports. m_xtmemory.c ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2016-2017 Philippe Waroquiers 11 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. 16 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. 21 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 25 02111-1307, USA. 26 27 The GNU General Public License is contained in the file COPYING. 28 */ 29 30 #include "pub_core_libcassert.h" 31 #include "pub_core_libcbase.h" 32 #include "pub_core_libcprint.h" 33 #include "pub_core_libcproc.h" 34 #include "pub_core_mallocfree.h" 35 #include "pub_core_options.h" 36 #include "pub_core_xarray.h" 37 #include "pub_core_xtree.h" 38 #include "pub_core_xtmemory.h" /* self */ 39 40 static void VG_(XT_Allocs_init)(void* xt_allocs) 41 { 42 VG_(memset) (xt_allocs, 0, sizeof(XT_Allocs)); 43 } 44 static void VG_(XT_Allocs_add) (void* to, const void* xt_allocs) 45 { 46 XT_Allocs* xto = to; 47 const XT_Allocs* xta = xt_allocs; 48 49 xto->nbytes += xta->nbytes; 50 xto->nblocks += xta->nblocks; 51 } 52 static void VG_(XT_Allocs_sub) (void* from, const void* xt_allocs) 53 { 54 XT_Allocs* xfrom = from; 55 const XT_Allocs* xta = xt_allocs; 56 57 xfrom->nbytes -= xta->nbytes; 58 xfrom->nblocks -= xta->nblocks; 59 } 60 static const HChar* VG_(XT_Allocs_img) (const void* xt_allocs) 61 { 62 static HChar buf[100]; 63 64 const XT_Allocs* xta = xt_allocs; 65 66 if (xta->nbytes > 0 || xta->nblocks > 0) { 67 VG_(sprintf) (buf, "%lu %lu", 68 xta->nbytes, xta->nblocks); 69 return buf; 70 } else { 71 return NULL; 72 } 73 } 74 const HChar* XT_Allocs_events = "curB : currently allocated Bytes" "," 75 "curBk : currently allocated Blocks"; 76 77 /* Type and functions for full xtree memory profiling. */ 78 static XTree* full_xt; 79 typedef 80 struct _XT_Full { 81 // Current nr of bytes/blocks allocated by this ec 82 SizeT cur_alloc_nbytes; 83 SizeT cur_alloc_nblocks; 84 85 // Total/cumulative nr of bytes/blocks allocated by this ec 86 ULong tot_alloc_nbytes; 87 ULong tot_alloc_nblocks; 88 89 // Total/cumulative nr of bytes/blocks freed by this ec 90 ULong tot_freed_nbytes; 91 ULong tot_freed_nblocks; 92 } XT_Full; 93 /* Note: normally, an ec should never be used as both an alloc_ec and 94 a free_ec. This implies that we should never have a XT_Full that has 95 at the same time some alloc and some freed components > 0. 96 We however still will support this possibility, just in case very 97 strange ec are produced and/or given by the tool. */ 98 99 static void VG_(XT_Full_init)(void* xtfull) 100 { 101 VG_(memset) (xtfull, 0, sizeof(XT_Full)); 102 } 103 static void VG_(XT_Full_add) (void* to, const void* xtfull) 104 { 105 XT_Full* xto = to; 106 const XT_Full* xtf = xtfull; 107 108 xto->cur_alloc_nbytes += xtf->cur_alloc_nbytes; 109 xto->cur_alloc_nblocks += xtf->cur_alloc_nblocks; 110 xto->tot_alloc_nbytes += xtf->tot_alloc_nbytes; 111 xto->tot_alloc_nblocks += xtf->tot_alloc_nblocks; 112 xto->tot_freed_nbytes += xtf->tot_freed_nbytes; 113 xto->tot_freed_nblocks += xtf->tot_freed_nblocks; 114 } 115 static void VG_(XT_Full_sub) (void* from, const void* xtfull) 116 { 117 XT_Full* xfrom = from; 118 const XT_Full* xtf = xtfull; 119 120 xfrom->cur_alloc_nbytes -= xtf->cur_alloc_nbytes; 121 xfrom->cur_alloc_nblocks -= xtf->cur_alloc_nblocks; 122 xfrom->tot_alloc_nbytes -= xtf->tot_alloc_nbytes; 123 xfrom->tot_alloc_nblocks -= xtf->tot_alloc_nblocks; 124 xfrom->tot_freed_nbytes -= xtf->tot_freed_nbytes; 125 xfrom->tot_freed_nblocks -= xtf->tot_freed_nblocks; 126 } 127 static const HChar* VG_(XT_Full_img) (const void* xtfull) 128 { 129 static HChar buf[300]; 130 131 const XT_Full* xtf = xtfull; 132 133 if ( xtf->cur_alloc_nbytes > 0 134 || xtf->cur_alloc_nblocks > 0 135 || xtf->tot_alloc_nbytes > 0 136 || xtf->tot_alloc_nblocks > 0 137 || xtf->tot_freed_nbytes > 0 138 || xtf->tot_freed_nblocks > 0) { 139 VG_(sprintf) (buf, 140 "%lu %lu " 141 "%llu %llu " 142 "%llu %llu", 143 xtf->cur_alloc_nbytes, xtf->cur_alloc_nblocks, 144 xtf->tot_alloc_nbytes, xtf->tot_alloc_nblocks, 145 xtf->tot_freed_nbytes, xtf->tot_freed_nblocks); 146 return buf; 147 } else { 148 return NULL; 149 } 150 } 151 static const HChar* XT_Full_events = 152 "curB : currently allocated Bytes" "," 153 "curBk : currently allocated Blocks" "," 154 "totB : total allocated Bytes" "," 155 "totBk : total allocated Blocks" "," 156 "totFdB : total Freed Bytes" "," 157 "totFdBk : total Freed Blocks"; 158 void VG_(XTMemory_Full_init)(XT_filter_IPs_t filter_IPs_fn) 159 { 160 full_xt = VG_(XT_create) (VG_(malloc), 161 "m_xtree.full_xt", 162 VG_(free), 163 sizeof(XT_Full), 164 VG_(XT_Full_init), 165 VG_(XT_Full_add), 166 VG_(XT_Full_sub), 167 filter_IPs_fn); 168 } 169 void VG_(XTMemory_Full_alloc)(SizeT szB, 170 ExeContext* ec_alloc) 171 { 172 XT_Full xtf = {szB, 1, szB, 1, 0, 0}; 173 VG_(XT_add_to_ec)(full_xt, ec_alloc, &xtf); 174 } 175 void VG_(XTMemory_Full_free)(SizeT szB, 176 ExeContext* ec_alloc, 177 ExeContext* ec_free) 178 { 179 // substract from ec_alloc the freed memory. 180 XT_Full xtf_sub = {szB, 1, 0, 0, 0, 0}; 181 VG_(XT_sub_from_ec)(full_xt, ec_alloc, &xtf_sub); 182 183 // add to ec_free the freed memory 184 XT_Full xtf_add = {0, 0, 0, 0, szB, 1}; 185 VG_(XT_add_to_ec)(full_xt, ec_free, &xtf_add); 186 } 187 188 void VG_(XTMemory_Full_resize_in_place)(SizeT oldSzB, SizeT newSzB, 189 ExeContext* ec_alloc) 190 { 191 if (oldSzB > newSzB) { 192 XT_Full xtf = {oldSzB - newSzB, 0, oldSzB - newSzB, 0, 0, 0}; 193 VG_(XT_sub_from_ec)(full_xt, ec_alloc, &xtf); 194 } else { 195 XT_Full xtf = {newSzB - oldSzB, 0, newSzB - oldSzB, 0, 0, 0}; 196 VG_(XT_add_to_ec)(full_xt, ec_alloc, &xtf); 197 } 198 } 199 200 // Indicates which event nr the report_value function must return. 201 static UInt event_report_value_id; 202 static ULong XT_Full_report_value(const void* xtfull) 203 { 204 const XT_Full* xtf = xtfull; 205 switch (event_report_value_id) { 206 case 0: return (ULong) xtf->cur_alloc_nbytes; 207 case 1: return (ULong) xtf->cur_alloc_nblocks; 208 case 2: return xtf->tot_alloc_nbytes; 209 case 3: return xtf->tot_alloc_nblocks; 210 case 4: return xtf->tot_freed_nbytes; 211 case 5: return xtf->tot_freed_nblocks; 212 default: vg_assert(0); 213 } 214 } 215 static ULong XT_Allocs_report_value(const void* xt_allocs) 216 { 217 const XT_Allocs* xta = xt_allocs; 218 switch (event_report_value_id) { 219 case 0: return (ULong) xta->nbytes; 220 case 1: return (ULong) xta->nblocks; 221 default: vg_assert(0); 222 } 223 } 224 225 static void produce_report(XTree* xt, const HChar* filename, 226 const HChar* events, 227 const HChar* (*img_value) (const void* value), 228 ULong (*report_value)(const void* value)) 229 { 230 /* The user can control the kind of report using filename extension. */ 231 if (VG_(strstr)(filename, ".ms")) { 232 /* If needed, some harcoded value below could become parameters. */ 233 MsFile* fp; 234 Massif_Header header = (Massif_Header) { 235 .snapshot_n = 0, 236 .time = VG_(read_millisecond_timer)(), 237 .sz_B = 0ul, 238 .extra_B = 0ul, 239 .stacks_B = 0ul, 240 .detailed = True, 241 .peak = False, 242 .top_node_desc = NULL, 243 .sig_threshold = 0.00000000000001 244 // Currently, we take a very small float value to not output 245 // the 0 values, but still output all the rest. 246 }; 247 248 // Variables to parse events 249 HChar strtok_events[VG_(strlen)(events)+1]; 250 HChar* e; 251 HChar* ssaveptr; 252 253 fp = VG_(XT_massif_open)(filename, 254 "xtree.produce_report", 255 NULL, 256 "ms"); 257 258 event_report_value_id = 0; 259 VG_(strcpy)(strtok_events, events); 260 for (e = VG_(strtok_r) (strtok_events, ",", &ssaveptr); 261 e != NULL; 262 e = VG_(strtok_r) (NULL, ",", &ssaveptr)) { 263 header.top_node_desc = e; 264 VG_(XT_massif_print)(fp, xt, &header, report_value); 265 header.snapshot_n++; 266 event_report_value_id++; 267 } 268 269 VG_(XT_massif_close)(fp); 270 } else 271 VG_(XT_callgrind_print)(xt, 272 filename, 273 events, 274 img_value); 275 } 276 277 void VG_(XTMemory_report) 278 (const HChar* filename, Bool fini, 279 void (*next_block)(XT_Allocs* xta, ExeContext** ec_alloc), 280 XT_filter_IPs_t filter_IPs_fn) 281 { 282 HChar* expanded_filename; 283 284 if (fini && VG_(clo_xtree_memory) == Vg_XTMemory_None) 285 return; 286 287 expanded_filename 288 = VG_(expand_file_name)("--xtree-memory-file", 289 (filename == NULL) ? 290 (fini ? 291 VG_(clo_xtree_memory_file) 292 : "xtmemory.kcg.%p.%n") 293 : filename); 294 295 /* fini is False => even if user kept --xtree-memory=none, we 296 produce a report when explicitely requested e.g. via a monitor 297 command. */ 298 switch (VG_(clo_xtree_memory)) { 299 case Vg_XTMemory_None: 300 case Vg_XTMemory_Allocs: { 301 XTree* xt; 302 XT_Allocs xta; 303 ExeContext* ec_alloc; 304 305 xt = VG_(XT_create) (VG_(malloc), 306 "VG_(XTMemory_report)", 307 VG_(free), 308 sizeof(XT_Allocs), 309 VG_(XT_Allocs_init), 310 VG_(XT_Allocs_add), 311 VG_(XT_Allocs_sub), 312 filter_IPs_fn); 313 (*next_block)(&xta, &ec_alloc); 314 while ( xta.nblocks > 0 ) { 315 VG_(XT_add_to_ec) (xt, ec_alloc, &xta); 316 (*next_block)(&xta, &ec_alloc); 317 } 318 319 produce_report(xt, expanded_filename, 320 XT_Allocs_events, VG_(XT_Allocs_img), 321 XT_Allocs_report_value); 322 323 VG_(XT_delete)(xt); 324 break; 325 } 326 case Vg_XTMemory_Full: 327 produce_report(full_xt, expanded_filename, 328 XT_Full_events, VG_(XT_Full_img), 329 XT_Full_report_value); 330 break; 331 default: 332 vg_assert(0); 333 } 334 if (VG_(clo_verbosity) >= 1 || !fini) 335 VG_(umsg)("xtree memory report: %s\n", expanded_filename); 336 337 VG_(free)(expanded_filename); 338 } 339 340 /*--------------------------------------------------------------------*/ 341 /*--- end m_xtree.c ---*/ 342 /*--------------------------------------------------------------------*/ 343
