gitorious.org Git - qtwebkit:performance.git/blob - host-tools/memusagestat/memusagestat.c

1 /* Generate graphic from memory profiling data.

3 This file is part of the GNU C Library.

4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.

6 This program is free software; you can redistribute it and/or modify

7 it under the terms of the GNU General Public License as published

8 by the Free Software Foundation; version 2 of the License, or

9 (at your option) any later version.

11 This program is distributed in the hope that it will be useful,

12 but WITHOUT ANY WARRANTY; without even the implied warranty of

13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14 GNU General Public License for more details.

16 You should have received a copy of the GNU General Public License

17 along with this program; if not, write to the Free Software Foundation,

18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

20 #define _FILE_OFFSET_BITS 64

22 #include <argp.h>

23 #include <assert.h>

24 #include <errno.h>

25 #include <error.h>

26 #include <fcntl.h>

27 #include <getopt.h>

28 #include <inttypes.h>

29 #include <libintl.h>

30 #include <stdio.h>

31 #include <stdlib.h>

32 #include <string.h>

33 #include <unistd.h>

34 #include <sys/param.h>

35 #include <sys/stat.h>

37 #include <gd.h>

38 #include <gdfontl.h>

39 #include <gdfonts.h>

42 /* Default size of the generated image. */

43 #define XSIZE 800

44 #define YSIZE 600

46 #ifndef N_

47 # define N_(Arg) Arg

48 #endif

51 /* Definitions of arguments for argp functions. */

52 static const struct argp_option options[] =

53 {

54 { "output", 'o', "FILE", 0, N_("Name output file") },

55 { "string", 's', "STRING", 0, N_("Title string used in output graphic") },

56 { "time", 't', NULL, 0, N_("Generate output linear to time (default is linear to number of function calls)") },

57 { "total", 'T', NULL, 0,

58 N_("Also draw graph for total memory consumption") },

59 { "x-size", 'x', "VALUE", 0, N_("Make output graphic VALUE pixels wide") },

60 { "y-size", 'y', "VALUE", 0, N_("Make output graphic VALUE pixels high") },

61 { NULL, 0, NULL, 0, NULL }

62 };

64 /* Short description of program. */

65 static const char doc[] = N_("Generate graphic from memory profiling data");

67 /* Strings for arguments in help texts. */

68 static const char args_doc[] = N_("DATAFILE [OUTFILE]");

70 /* Prototype for option handler. */

71 static error_t parse_opt (int key, char *arg, struct argp_state *state);

73 /* Function to print some extra text in the help message. */

74 static char *more_help (int key, const char *text, void *input);

76 /* Data structure to communicate with argp functions. */

77 static struct argp argp =

78 {

79 options, parse_opt, args_doc, doc, NULL, more_help

80 };

83 struct entry

84 {

85 uint64_t heap;

86 uint64_t stack;

87 uint32_t time_low;

88 uint32_t time_high;

89 };

92 /* Size of the image. */

93 static size_t xsize;

94 static size_t ysize;

96 /* Name of the output file. */

97 static char *outname;

99 /* Title string for the graphic. */

100 static const char *string;

101

102 /* Nonzero if graph should be generated linear in time. */

103 static int time_based;

104

105 /* Nonzero if graph to display total use of memory should be drawn as well. */

106 static int also_total = 0;

107

108

109 int

110 main (int argc, char *argv[])

111 {

112 int remaining;

113 const char *inname;

114 gdImagePtr im_out;

115 int grey, blue, red, green, yellow, black;

116 int fd;

117 struct stat st;

118 uint64_t maxsize_heap;

119 uint64_t maxsize_stack;

120 uint64_t maxsize_total;

121 uint64_t total;

122 uint64_t cnt, cnt2;

123 FILE *outfile;

124 char buf[30];

125 size_t last_heap;

126 size_t last_stack;

127 size_t last_total;

128 struct entry headent[2];

129 uint64_t start_time;

130 uint64_t end_time;

131 uint64_t total_time;

132 const char *heap_format, *stack_format;

133 int heap_scale, stack_scale, line;

134

135 outname = NULL;

136 xsize = XSIZE;

137 ysize = YSIZE;

138 string = NULL;

139

140 /* Parse and process arguments. */

141 argp_parse (&argp, argc, argv, 0, &remaining, NULL);

142

143 if (remaining >= argc || remaining + 2 < argc)

144 {

145 argp_help (&argp, stdout, ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR,

146 "memusagestat");

147 exit (1);

148 }

149

150 inname = argv[remaining++];

151

152 if (remaining < argc)

153 outname = argv[remaining];

154 else if (outname == NULL)

155 {

156 size_t len = strlen (inname);

157 outname = alloca (len + 5);

158 stpcpy (stpcpy (outname, inname), ".png");

159 }

160

161 /* Open for read/write since we try to repair the file in case the

162 application hasn't terminated cleanly. */

163 fd = open (inname, O_RDWR);

164 if (fd == -1)

165 error (EXIT_FAILURE, errno, "cannot open input file");

166 if (fstat (fd, &st) != 0)

167 {

168 close (fd);

169 error (EXIT_FAILURE, errno, "cannot get size of input file");

170 }

171 /* Test whether the file contains only full records. */

172 if ((st.st_size % sizeof (struct entry)) != 0

173 /* The file must at least contain the two administrative records. */

174 || st.st_size < 2 * sizeof (struct entry))

175 {

176 close (fd);

177 error (EXIT_FAILURE, 0, "input file has incorrect size");

178 }

179 /* Compute number of data entries. */

180 total = st.st_size / sizeof (struct entry) - 2;

181

182 /* Read the administrative information. */

183 read (fd, headent, sizeof (headent));

184

185 start_now:

186 maxsize_heap = headent[1].heap;

187 maxsize_stack = headent[1].stack;

188 maxsize_total = headent[0].stack;

189 if (also_total)

190 {

191 /* We use one scale and since we also draw the total amount of

192 memory used we have to adapt the maximum. */

193 maxsize_heap = maxsize_total;

194 maxsize_stack = maxsize_total;

195 }

196

197 if (maxsize_heap == 0 && maxsize_stack == 0)

198 {

199 /* The program aborted before memusage was able to write the

200 information about the maximum heap and stack use. Repair

201 the file now. */

202 struct entry next;

203

204 while (1)

205 {

206 if (read (fd, &next, sizeof (next)) == 0)

207 break;

208 if (next.heap > headent[1].heap)

209 headent[1].heap = next.heap;

210 if (next.stack > headent[1].stack)

211 headent[1].stack = next.stack;

212 }

213

214 headent[1].time_low = next.time_low;

215 headent[1].time_high = next.time_high;

216

217 /* Write the computed values in the file. */

218 lseek (fd, sizeof (struct entry), SEEK_SET);

219 write (fd, &headent[1], sizeof (struct entry));

220 goto start_now;

221 }

222

223 printf("MAX: total: %llu stack: %llu heap: %llu\n", maxsize_total, maxsize_stack, maxsize_heap);

224 start_time = ((uint64_t) headent[0].time_high) << 32 | headent[0].time_low;

225 end_time = ((uint64_t) headent[1].time_high) << 32 | headent[1].time_low;

226 total_time = end_time - start_time;

227

228 if (xsize < 100)

229 xsize = 100;

230 if (ysize < 80)

231 ysize = 80;

232

233 /* Create output image with the specified size. */

234 im_out = gdImageCreate (xsize, ysize);

235

236 /* First color allocated is background. */

237 grey = gdImageColorAllocate (im_out, 224, 224, 224);

238

239 /* Set transparent color. */

240 gdImageRectangle(im_out, 0, 0, xsize, ysize, grey);

241

242 /* These are all the other colors we need (in the moment). */

243 red = gdImageColorAllocate (im_out, 255, 0, 0);

244 green = gdImageColorAllocate (im_out, 0, 130, 0);

245 blue = gdImageColorAllocate (im_out, 0, 0, 255);

246 yellow = gdImageColorAllocate (im_out, 154, 205, 50);

247 black = gdImageColorAllocate (im_out, 0, 0, 0);

248

249 gdImageRectangle (im_out, 40, 20, xsize - 40, ysize - 20, blue);

250

251 if (maxsize_heap < 1024)

252 {

253 heap_format = "%Zu";

254 heap_scale = 1;

255 }

256 else if (maxsize_heap < 1024 * 1024 * 100)

257 {

258 heap_format = "%Zuk";

259 heap_scale = 1024;

260 }

261 else

262 {

263 heap_format = "%ZuM";

264 heap_scale = 1024 * 1024;

265 }

266

267 if (maxsize_stack < 1024)

268 {

269 stack_format = "%Zu";

270 stack_scale = 1;

271 }

272 else if (maxsize_stack < 1024 * 1024 * 100)

273 {

274 stack_format = "%Zuk";

275 stack_scale = 1024;

276 }

277 else

278 {

279 stack_format = "%ZuM";

280 stack_scale = 1024 * 1024;

281 }

282

283 gdImageString (im_out, gdFontSmall, 38, ysize - 14, (unsigned char *) "0",

284 blue);

285 snprintf (buf, sizeof (buf), heap_format, 0);

286 gdImageString (im_out, gdFontSmall, maxsize_heap < 1024 ? 32 : 26,

287 ysize - 26, (unsigned char *) buf, red);

288 snprintf (buf, sizeof (buf), stack_format, 0);

289 gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26,

290 (unsigned char *) buf, green);

291

292 if (string != NULL)

293 gdImageString (im_out, gdFontLarge, (xsize - strlen (string) * 8) / 2,

294 2, (unsigned char *) string, green);

295

296 gdImageStringUp (im_out, gdFontSmall, 1, ysize / 2 - 10,

297 (unsigned char *) "allocated", red);

298 gdImageStringUp (im_out, gdFontSmall, 11, ysize / 2 - 10,

299 (unsigned char *) "memory", red);

300

301 gdImageStringUp (im_out, gdFontSmall, xsize - 39, ysize / 2 - 10,

302 (unsigned char *) "used", green);

303 gdImageStringUp (im_out, gdFontSmall, xsize - 27, ysize / 2 - 10,

304 (unsigned char *) "stack", green);

305

306 snprintf (buf, sizeof (buf), heap_format, maxsize_heap / heap_scale);

307 gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6, 14,

308 (unsigned char *) buf, red);

309 snprintf (buf, sizeof (buf), stack_format, maxsize_stack / stack_scale);

310 gdImageString (im_out, gdFontSmall, xsize - 37, 14,

311 (unsigned char *) buf, green);

312

313 for (line = 1; line <= 3; ++line)

314 {

315 cnt = ((ysize - 40) * (maxsize_heap / 4 * line / heap_scale)) /

316 (maxsize_heap / heap_scale);

317 gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,

318 ysize - 20 - cnt, red);

319 snprintf (buf, sizeof (buf), heap_format, maxsize_heap / 4 * line /

320 heap_scale);

321 gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,

322 ysize - 26 - cnt, (unsigned char *) buf, red);

323

324 cnt2 = ((ysize - 40) * (maxsize_stack / 4 * line / stack_scale)) /

325 (maxsize_stack / stack_scale);

326 if (cnt != cnt2)

327 gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,

328 ysize - 20 - cnt2, green);

329 snprintf (buf, sizeof (buf), stack_format, maxsize_stack / 4 * line /

330 stack_scale);

331 gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,

332 (unsigned char *) buf, green);

333 }

334

335 snprintf (buf, sizeof (buf), "%llu", (unsigned long long) total);

336 gdImageString (im_out, gdFontSmall, xsize - 50, ysize - 14,

337 (unsigned char *) buf, blue);

338

339 if (!time_based)

340 {

341 uint64_t previously = start_time;

342

343 gdImageString (im_out, gdFontSmall, 40 + (xsize - 32 * 6 - 80) / 2,

344 ysize - 12,

345 (unsigned char *) "# memory handling function calls",

346 blue);

347

348

349 last_stack = last_heap = last_total = ysize - 20;

350 for (cnt = 1; cnt <= total; ++cnt)

351 {

352 struct entry entry;

353 size_t new[2];

354 uint64_t now;

355

356 read (fd, &entry, sizeof (entry));

357

358 now = ((uint64_t) entry.time_high) << 32 | entry.time_low;

359

360 if ((((previously - start_time) * 100) / total_time) % 10 < 5)

361 gdImageFilledRectangle (im_out,

362 40 + ((cnt - 1) * (xsize - 80)) / total,

363 ysize - 19,

364 39 + (cnt * (xsize - 80)) / total,

365 ysize - 14, yellow);

366 previously = now;

367

368 if (also_total)

369 {

370 size_t new3;

371

372 new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))

373 * (entry.heap + entry.stack))

374 / maxsize_heap);

375 gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,

376 last_total,

377 40 + ((xsize - 80) * cnt) / total, new3,

378 black);

379 last_total = new3;

380 }

381

382 // assert (entry.heap <= maxsize_heap);

383 new[0] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))

384 * entry.heap) / maxsize_heap);

385 gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,

386 last_heap, 40 + ((xsize - 80) * cnt) / total, new[0],

387 red);

388 last_heap = new[0];

389

390 // assert (entry.stack <= maxsize_stack);

391 new[1] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))

392 * entry.stack) / maxsize_stack);

393 gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,

394 last_stack, 40 + ((xsize - 80) * cnt) / total, new[1],

395 green);

396 last_stack = new[1];

397 }

398

399 cnt = 0;

400 while (cnt < total)

401 {

402 gdImageLine (im_out, 40 + ((xsize - 80) * cnt) / total, ysize - 20,

403 40 + ((xsize - 80) * cnt) / total, ysize - 15, blue);

404 cnt += MAX (1, total / 20);

405 }

406 gdImageLine (im_out, xsize - 40, ysize - 20, xsize - 40, ysize - 15,

407 blue);

408 }

409 else

410 {

411 uint64_t next_tick = MAX (1, total / 20);

412 size_t last_xpos = 40;

413

414 gdImageString (im_out, gdFontSmall, 40 + (xsize - 39 * 6 - 80) / 2,

415 ysize - 12,

416 (unsigned char *) "\

417 # memory handling function calls / time", blue);

418

419 for (cnt = 0; cnt < 20; cnt += 2)

420 gdImageFilledRectangle (im_out,

421 40 + (cnt * (xsize - 80)) / 20, ysize - 19,

422 39 + ((cnt + 1) * (xsize - 80)) / 20,

423 ysize - 14, yellow);

424

425 last_stack = last_heap = last_total = ysize - 20;

426 for (cnt = 1; cnt <= total; ++cnt)

427 {

428 struct entry entry;

429 size_t new[2];

430 size_t xpos;

431 uint64_t now;

432

433 read (fd, &entry, sizeof (entry));

434

435 now = ((uint64_t) entry.time_high) << 32 | entry.time_low;

436 xpos = 40 + ((xsize - 80) * (now - start_time)) / total_time;

437

438 if (cnt == next_tick)

439 {

440 gdImageLine (im_out, xpos, ysize - 20, xpos, ysize - 15, blue);

441 next_tick += MAX (1, total / 20);

442 }

443

444 if (also_total)

445 {

446 size_t new3;

447

448 new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))

449 * (entry.heap + entry.stack))

450 / maxsize_heap);

451 gdImageLine (im_out, last_xpos, last_total, xpos, new3, black);

452 last_total = new3;

453 }

454

455 new[0] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))

456 * entry.heap) / maxsize_heap);

457 gdImageLine (im_out, last_xpos, last_heap, xpos, new[0], red);

458 last_heap = new[0];

459

460 // assert (entry.stack <= maxsize_stack);

461 new[1] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))

462 * entry.stack) / maxsize_stack);

463 gdImageLine (im_out, last_xpos, last_stack, xpos, new[1], green);

464 last_stack = new[1];

465

466 last_xpos = xpos;

467 }

468 }

469

470 /* Write out the result. */

471 outfile = fopen (outname, "w");

472 if (outfile == NULL)

473 error (EXIT_FAILURE, errno, "cannot open output file");

474

475 gdImagePng (im_out, outfile);

476

477 fclose (outfile);

478

479 gdImageDestroy (im_out);

480

481 return 0;

482 }

483

484

485 /* Handle program arguments. */

486 static error_t

487 parse_opt (int key, char *arg, struct argp_state *state)

488 {

489 switch (key)

490 {

491 case 'o':

492 outname = arg;

493 break;

494 case 's':

495 string = arg;

496 break;

497 case 't':

498 time_based = 1;

499 break;

500 case 'T':

501 also_total = 1;

502 break;

503 case 'x':

504 xsize = atoi (arg);

505 if (xsize == 0)

506 xsize = XSIZE;

507 break;

508 case 'y':

509 ysize = atoi (arg);

510 if (ysize == 0)

511 ysize = XSIZE;

512 break;

513 default:

514 return ARGP_ERR_UNKNOWN;

515 }

516 return 0;

517 }

518

519

520 static char *

521 more_help (int key, const char *text, void *input)

522 {

523 char *orig;

524 char *cp;

525

526 switch (key)

527 {

528 case ARGP_KEY_HELP_EXTRA:

529 /* We print some extra information. */

530 orig = gettext ("\

531 For bug reporting instructions, please see:\n\

532 <http://www.gnu.org/software/libc/bugs.html>.\n");

533 cp = strdup (orig);

534 if (cp == NULL)

535 cp = orig;

536 return cp;

537 default:

538 break;

539 }

540 return (char *) text;

541 }