]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gprofng/src/Experiment.cc
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update year range in copyright notice of binutils files
[thirdparty/binutils-gdb.git] / gprofng / src / Experiment.cc
1 /* Copyright (C) 2021-2024 Free Software Foundation, Inc.
2 Contributed by Oracle.
3
4 This file is part of GNU Binutils.
5
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 by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
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.
15
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
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "config.h"
22 #include <errno.h>
23 #include <utime.h>
24 #include <alloca.h>
25 #include <dirent.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <sys/param.h>
31 #include <set>
32
33 #include "util.h"
34 #include "CacheMap.h"
35 #include "DbeFile.h"
36 #include "DbeCacheMap.h"
37 #include "DefaultHandler.h"
38 #include "DefaultMap2D.h"
39 #include "Emsg.h"
40 #include "Elf.h"
41 #include "SAXParser.h"
42 #include "SAXParserFactory.h"
43 #include "StringBuilder.h"
44 #include "DbeSession.h"
45 #include "DbeThread.h"
46 #include "Application.h"
47 #include "CallStack.h"
48 #include "Experiment.h"
49 #include "Exp_Layout.h"
50 #include "DataStream.h"
51 #include "Expression.h"
52 #include "Function.h"
53 #include "HeapMap.h"
54 #include "LoadObject.h"
55 #include "Module.h"
56 #include "Ovw_data.h"
57 #include "PRBTree.h"
58 #include "Sample.h"
59 #include "SegMem.h"
60 #include "StringMap.h"
61 #include "UserLabel.h"
62 #include "Table.h"
63 #include "dbe_types.h"
64 #include "FileData.h"
65 #include "cc_libcollector.h"
66 #include "ExpGroup.h"
67
68 int nPush;
69 int nPop;
70 int pushCnt;
71 int popCnt;
72 int pushCnt3;
73 int popCnt3;
74
75 struct Experiment::UIDnode
76 {
77 uint64_t uid;
78 uint64_t val;
79 UIDnode *next;
80 };
81
82 struct Experiment::RawFramePacket
83 {
84 uint64_t uid;
85 UIDnode *uidn;
86 UIDnode *uidj;
87 UIDnode *omp_uid;
88 uint32_t omp_state;
89 };
90
91 static hrtime_t
92 parseTStamp (const char *s)
93 {
94 hrtime_t ts = (hrtime_t) 0;
95 ts = (hrtime_t) atoi (s) * NANOSEC;
96 s = strchr (s, '.');
97 if (s != NULL)
98 ts += (hrtime_t) atoi (s + 1);
99 return ts;
100 }
101
102 class Experiment::ExperimentFile
103 {
104 public:
105
106 enum
107 {
108 EF_NOT_OPENED,
109 EF_OPENED,
110 EF_CLOSED,
111 EF_FAILURE
112 };
113
114 ExperimentFile (Experiment *_exp, const char *_fname);
115 ~ExperimentFile ();
116
117 bool open (bool new_open = false);
118
119 char *
120 get_name ()
121 {
122 return fname;
123 }
124
125 inline int
126 get_status ()
127 {
128 return ef_status;
129 }
130
131 char *fgets ();
132 void close ();
133
134 FILE *fh;
135
136 private:
137 Experiment *exp;
138 char *fname;
139 off64_t offset;
140 int bufsz, ef_status;
141 char *buffer;
142 };
143
144 class Experiment::ExperimentHandler : public DefaultHandler
145 {
146 public:
147
148 ExperimentHandler (Experiment *_exp);
149 ~ExperimentHandler ();
150
151 void
152 startDocument () { }
153 void endDocument ();
154 void startElement (char *uri, char *localName, char *qName, Attributes *attrs);
155 void endElement (char *uri, char *localName, char *qName);
156 void characters (char *ch, int start, int length);
157
158 void
159 ignorableWhitespace (char*, int, int) { }
160 void
161 error (SAXParseException *e);
162
163 private:
164
165 enum Element
166 {
167 EL_NONE,
168 EL_EXPERIMENT,
169 EL_COLLECTOR,
170 EL_SETTING,
171 EL_PROCESS,
172 EL_SYSTEM,
173 EL_EVENT,
174 EL_PROFILE,
175 EL_DATAPTR,
176 EL_PROFDATA,
177 EL_PROFPCKT,
178 EL_FIELD,
179 EL_CPU,
180 EL_STATE,
181 EL_FREQUENCY,
182 EL_POWERM,
183 EL_DTRACEFATAL
184 };
185
186 static int toInt (Attributes *attrs, const char *atr);
187 static char*toStr (Attributes *attrs, const char *atr);
188 void pushElem (Element);
189 void popElem ();
190
191 Experiment *exp;
192 Element curElem;
193 Vector<Element> *stack;
194 Module *dynfuncModule;
195 DataDescriptor *dDscr;
196 PacketDescriptor *pDscr;
197 PropDescr *propDscr;
198 char *text;
199 Cmsg_warn mkind;
200 int mnum;
201 int mec;
202 };
203
204
205 // HTableSize is the size of smemHTable and instHTable
206 // omazur: both HTableSize and the hash function haven't been tuned;
207 static const int HTableSize = 8192;
208
209 //-------------------------------------------------- Experiment file handler
210
211 Experiment::ExperimentFile::ExperimentFile (Experiment *_exp, const char *_fname)
212 {
213 exp = _exp;
214 fh = NULL;
215 bufsz = 0;
216 buffer = NULL;
217 ef_status = EF_NOT_OPENED;
218 offset = 0;
219 fname = dbe_sprintf (NTXT ("%s/%s"), exp->expt_name, _fname);
220 }
221
222 Experiment::ExperimentFile::~ExperimentFile ()
223 {
224 close ();
225 free (buffer);
226 free (fname);
227 }
228
229 bool
230 Experiment::ExperimentFile::open (bool new_open)
231 {
232 if (fh == NULL)
233 {
234 fh = fopen64 (fname, NTXT ("r"));
235 if (fh == NULL)
236 {
237 ef_status = EF_FAILURE;
238 return false;
239 }
240 ef_status = EF_OPENED;
241 if (new_open)
242 offset = 0;
243 if (offset != 0)
244 fseeko64 (fh, offset, SEEK_SET);
245 }
246 return true;
247 }
248
249 char *
250 Experiment::ExperimentFile::fgets ()
251 {
252 if (bufsz == 0)
253 {
254 bufsz = 1024;
255 buffer = (char *) malloc (bufsz);
256 if (buffer == NULL)
257 return NULL;
258 buffer[bufsz - 1] = (char) 1; // sentinel
259 }
260 char *res = ::fgets (buffer, bufsz, fh);
261 if (res == NULL)
262 return NULL;
263 while (buffer[bufsz - 1] == (char) 0)
264 {
265 int newsz = bufsz + 1024;
266 char *newbuf = (char *) malloc (newsz);
267 if (newbuf == NULL)
268 return NULL;
269 memcpy (newbuf, buffer, bufsz);
270 free (buffer);
271 buffer = newbuf;
272 buffer[newsz - 1] = (char) 1; // sentinel
273 // we don't care about fgets result here
274 ::fgets (buffer + bufsz - 1, newsz - bufsz + 1, fh);
275 bufsz = newsz;
276 }
277 return buffer;
278 }
279
280 void
281 Experiment::ExperimentFile::close ()
282 {
283 if (fh)
284 {
285 offset = ftello64 (fh);
286 fclose (fh);
287 ef_status = EF_CLOSED;
288 fh = NULL;
289 }
290 }
291
292
293 //-------------------------------------------------- Experiment XML parser
294 int
295 Experiment::ExperimentHandler::toInt (Attributes *attrs, const char *atr)
296 {
297 const char *str = attrs->getValue (atr);
298 return str ? atoi (str) : 0;
299 }
300
301 char *
302 Experiment::ExperimentHandler::toStr (Attributes *attrs, const char *atr)
303 {
304 const char *str = attrs->getValue (atr);
305 return dbe_strdup (str ? str : NTXT (""));
306 }
307
308 Experiment::ExperimentHandler::ExperimentHandler (Experiment *_exp)
309 {
310 exp = _exp;
311 stack = new Vector<Element>;
312 pushElem (EL_NONE);
313 dynfuncModule = NULL;
314 dDscr = NULL;
315 pDscr = NULL;
316 propDscr = NULL;
317 text = NULL;
318 mkind = (Cmsg_warn) - 1; // CMSG_NONE
319 mnum = -1;
320 mec = -1;
321 }
322
323 Experiment::ExperimentHandler::~ExperimentHandler ()
324 {
325 delete stack;
326 free (text);
327 }
328
329 void
330 Experiment::ExperimentHandler::endDocument ()
331 {
332 { // SP_TAG_STATE should be used to describe states, but it isn't
333 // let's do it here:
334 DataDescriptor *dd = exp->getDataDescriptor (DATA_HEAP);
335 if (dd != NULL)
336 {
337 PropDescr *prop = dd->getProp (PROP_HTYPE);
338 if (prop != NULL)
339 {
340 char * stateNames [HEAPTYPE_LAST] = HEAPTYPE_STATE_STRINGS;
341 char * stateUNames[HEAPTYPE_LAST] = HEAPTYPE_STATE_USTRINGS;
342 for (int ii = 0; ii < HEAPTYPE_LAST; ii++)
343 prop->addState (ii, stateNames[ii], stateUNames[ii]);
344 }
345 }
346 dd = exp->getDataDescriptor (DATA_IOTRACE);
347 if (dd != NULL)
348 {
349 PropDescr *prop = dd->getProp (PROP_IOTYPE);
350 if (prop != NULL)
351 {
352 char * stateNames [IOTRACETYPE_LAST] = IOTRACETYPE_STATE_STRINGS;
353 char * stateUNames[IOTRACETYPE_LAST] = IOTRACETYPE_STATE_USTRINGS;
354 for (int ii = 0; ii < IOTRACETYPE_LAST; ii++)
355 prop->addState (ii, stateNames[ii], stateUNames[ii]);
356 }
357 }
358 }
359 }
360
361 void
362 Experiment::ExperimentHandler::pushElem (Element elem)
363 {
364 curElem = elem;
365 stack->append (curElem);
366 }
367
368 void
369 Experiment::ExperimentHandler::popElem ()
370 {
371 stack->remove (stack->size () - 1);
372 curElem = stack->fetch (stack->size () - 1);
373 }
374
375 void
376 Experiment::ExperimentHandler::startElement (char*, char*, char *qName, Attributes *attrs)
377 {
378 DEBUG_CODE if (DEBUG_SAXPARSER) dump_startElement (qName, attrs);
379 if (strcmp (qName, SP_TAG_EXPERIMENT) == 0)
380 {
381 pushElem (EL_EXPERIMENT);
382 const char *str = attrs->getValue (NTXT ("version"));
383 if (str != NULL)
384 {
385 int major = atoi (str);
386 str = strchr (str, '.');
387 int minor = str ? atoi (str + 1) : 0;
388 exp->exp_maj_version = major;
389 exp->exp_min_version = minor;
390 if (major != SUNPERF_VERNUM || minor != SUNPERF_VERNUM_MINOR)
391 {
392 // not the current version, see if we support some earlier versions
393 if (major < 12)
394 {
395 StringBuilder sb;
396 sb.sprintf (GTXT ("*** Error: experiment %s version %d.%d is not supported;\nuse the version of the tools that recorded the experiment to read it"),
397 exp->get_expt_name (), major, minor);
398 // exp->errorq->append( new Emsg(CMSG_FATAL, sb) );
399 exp->status = FAILURE;
400 exp->obsolete = 1;
401 throw new SAXException (sb.toString ());
402 }
403 }
404 }
405 }
406 else if (strcmp (qName, SP_TAG_COLLECTOR) == 0)
407 pushElem (EL_COLLECTOR);
408 else if (strcmp (qName, SP_TAG_SETTING) == 0)
409 {
410 int found = 0;
411 pushElem (EL_SETTING);
412 const char *str = attrs->getValue (SP_JCMD_LIMIT);
413 if (str != NULL)
414 {
415 found = 1;
416 exp->coll_params.limit = atoi (str);
417 }
418 str = attrs->getValue (SP_JCMD_BLKSZ);
419 if (str != NULL)
420 {
421 found = 1;
422 exp->blksz = strtol (str, NULL, 0);
423 }
424 str = attrs->getValue (SP_JCMD_STACKBASE);
425 if (str)
426 {
427 found = 1;
428 exp->stack_base = strtoull (str, NULL, 0);
429 }
430 str = attrs->getValue (SP_JCMD_HWC_DEFAULT);
431 if (str != NULL)
432 {
433 found = 1;
434 exp->hwc_default = true;
435 }
436 str = attrs->getValue (SP_JCMD_NOIDLE);
437 if (str != NULL)
438 {
439 found = 1;
440 exp->commentq->append (new Emsg (CMSG_COMMENT,
441 GTXT ("*** Note: experiment does not have events from idle CPUs")));
442 }
443 str = attrs->getValue (SP_JCMD_FAKETIME);
444 if (str != NULL)
445 {
446 found = 1;
447 exp->timelineavail = false;
448 exp->commentq->append (new Emsg (CMSG_COMMENT,
449 GTXT ("*** Note: experiment does not have timestamps; timeline unavailable")));
450 }
451 str = attrs->getValue (SP_JCMD_DELAYSTART);
452 if (str != NULL)
453 {
454 found = 1;
455 exp->coll_params.start_delay = strdup (str);
456 }
457 str = attrs->getValue (SP_JCMD_TERMINATE);
458 if (str != NULL)
459 {
460 found = 1;
461 exp->coll_params.terminate = strdup (str);
462 }
463 str = attrs->getValue (SP_JCMD_PAUSE_SIG);
464 if (str != NULL)
465 {
466 found = 1;
467 exp->coll_params.pause_sig = strdup (str);
468 }
469 str = attrs->getValue (SP_JCMD_SAMPLE_PERIOD);
470 if (str != NULL)
471 {
472 found = 1;
473 exp->coll_params.sample_periodic = 1;
474 exp->coll_params.sample_timer = atoi (str);
475 }
476 str = attrs->getValue (SP_JCMD_SAMPLE_SIG);
477 if (str != NULL)
478 {
479 found = 1;
480 exp->coll_params.sample_sig = str;
481 }
482 str = attrs->getValue (SP_JCMD_SRCHPATH);
483 if (str != NULL)
484 {
485 found = 1;
486 StringBuilder sb;
487 sb.sprintf (GTXT ("Search path: %s"), str);
488 exp->runlogq->append (new Emsg (CMSG_COMMENT, sb));
489 dbeSession->add_classpath ((char*) str);
490 }
491 str = attrs->getValue (SP_JCMD_LINETRACE);
492 if (str != NULL)
493 {
494 found = 1;
495 exp->coll_params.linetrace = strdup (str);
496 }
497
498 str = attrs->getValue (SP_JCMD_COLLENV);
499 if (str != NULL)
500 {
501 found = 1;
502 StringBuilder sb;
503 sb.sprintf (GTXT (" Data collection environment variable: %s"), str);
504 exp->runlogq->append (new Emsg (CMSG_COMMENT, sb));
505 }
506 if (found == 0)
507 {
508 int nattr = attrs->getLength ();
509 if (nattr != 0)
510 {
511 fprintf (stderr, "XXX Unexpected setting found; %d attributes:\n",
512 nattr);
513 for (int k = 0; k < nattr; k++)
514 {
515 const char *qn = attrs->getQName (k);
516 const char *vl = attrs->getValue (k);
517 fprintf (stderr, "XXX %s = %s\n", qn, vl);
518 }
519 }
520 }
521 // END OF CODE FOR "setting"
522 }
523 else if (strcmp (qName, SP_TAG_SYSTEM) == 0)
524 {
525 pushElem (EL_SYSTEM);
526 const char *str = attrs->getValue (NTXT ("hostname"));
527 if (str != NULL)
528 exp->hostname = strdup (str);
529 str = attrs->getValue (NTXT ("os"));
530 if (str != NULL)
531 {
532 exp->os_version = strdup (str);
533 /* For Linux experiments expect sparse thread ID's */
534 if (strncmp (str, NTXT ("SunOS"), 5) != 0)
535 exp->sparse_threads = true;
536 }
537 str = attrs->getValue (NTXT ("arch"));
538 if (str != NULL)
539 {
540 if (strcmp (str, "i86pc") == 0 || strcmp (str, "i686") == 0
541 || strcmp (str, "x86_64") == 0)
542 exp->platform = Intel;
543 else if (strcmp (str, "aarch64") == 0)
544 exp->platform = Aarch64;
545 else
546 exp->platform = Sparc;
547 exp->need_swap_endian = (DbeSession::platform == Sparc) ?
548 (exp->platform != Sparc) : (exp->platform == Sparc);
549 exp->architecture = strdup (str);
550 }
551 str = attrs->getValue (NTXT ("pagesz"));
552 if (str != NULL)
553 exp->page_size = atoi (str);
554 str = attrs->getValue (NTXT ("npages"));
555 if (str != NULL)
556 exp->npages = atoi (str);
557 }
558 else if (strcmp (qName, SP_TAG_POWERM) == 0)
559 pushElem (EL_POWERM);
560 else if (strcmp (qName, SP_TAG_FREQUENCY) == 0)
561 {
562 pushElem (EL_FREQUENCY);
563 const char *str = attrs->getValue (NTXT ("clk"));
564 if (str != NULL)
565 exp->set_clock (atoi (str));
566 // check for frequency_scaling or turbo_mode recorded from libcollector under dbx
567 str = attrs->getValue (NTXT ("frequency_scaling"));
568 const char *str2 = attrs->getValue (NTXT ("turbo_mode"));
569 if (str != NULL || str2 != NULL)
570 exp->varclock = 1;
571 }
572 else if (strcmp (qName, SP_TAG_CPU) == 0)
573 {
574 pushElem (EL_CPU);
575 exp->ncpus++;
576 const char *str = attrs->getValue (NTXT ("clk"));
577 if (str != NULL)
578 {
579 int clk = atoi (str);
580 if (exp->maxclock == 0)
581 {
582 exp->minclock = clk;
583 exp->maxclock = clk;
584 }
585 else
586 {
587 if (clk < exp->minclock)
588 exp->minclock = clk;
589 if (clk > exp->maxclock)
590 exp->maxclock = clk;
591 }
592 exp->clock = clk;
593 }
594 // check for frequency_scaling or turbo_mode
595 str = attrs->getValue (NTXT ("frequency_scaling"));
596 const char *str2 = attrs->getValue (NTXT ("turbo_mode"));
597 if (str != NULL || str2 != NULL)
598 exp->varclock = 1;
599 }
600 else if (strcmp (qName, SP_TAG_PROCESS) == 0)
601 {
602 pushElem (EL_PROCESS);
603 const char *str = attrs->getValue (NTXT ("wsize"));
604 if (str != NULL)
605 {
606 int wsz = atoi (str);
607 if (wsz == 32)
608 exp->wsize = W32;
609 else if (wsz == 64)
610 exp->wsize = W64;
611 }
612 str = attrs->getValue (NTXT ("pid"));
613 if (str != NULL)
614 exp->pid = atoi (str);
615 str = attrs->getValue (NTXT ("ppid"));
616 if (str != NULL)
617 exp->ppid = atoi (str);
618 str = attrs->getValue (NTXT ("pgrp"));
619 if (str != NULL)
620 exp->pgrp = atoi (str);
621 str = attrs->getValue (NTXT ("sid"));
622 if (str != NULL)
623 exp->sid = atoi (str);
624 str = attrs->getValue (NTXT ("cwd"));
625 if (str != NULL)
626 exp->ucwd = strdup (str);
627 str = attrs->getValue (NTXT ("pagesz"));
628 if (str != NULL)
629 exp->page_size = atoi (str);
630 }
631 else if (strcmp (qName, SP_TAG_EVENT) == 0)
632 { // Start code for event
633 pushElem (EL_EVENT);
634 hrtime_t ts = (hrtime_t) 0;
635 const char *str = attrs->getValue (NTXT ("tstamp"));
636 if (str != NULL)
637 ts = parseTStamp (str);
638 str = attrs->getValue (NTXT ("kind"));
639 if (str != NULL)
640 {
641 if (strcmp (str, SP_JCMD_RUN) == 0)
642 {
643 exp->broken = 0;
644 exp->exp_start_time = ts;
645 str = attrs->getValue (NTXT ("time"));
646 if (str != NULL)
647 exp->start_sec = atoll (str);
648 str = attrs->getValue (NTXT ("pid"));
649 if (str != NULL)
650 exp->pid = atoi (str);
651 str = attrs->getValue (NTXT ("ppid"));
652 if (str != NULL)
653 exp->ppid = atoi (str);
654 str = attrs->getValue (NTXT ("pgrp"));
655 if (str != NULL)
656 exp->pgrp = atoi (str);
657 str = attrs->getValue (NTXT ("sid"));
658 if (str != NULL)
659 exp->sid = atoi (str);
660 exp->status = Experiment::INCOMPLETE;
661 }
662 else if (strcmp (str, SP_JCMD_ARCHIVE) == 0)
663 {
664 StringBuilder sb;
665 sb.sprintf (GTXT ("gp-archive run: XXXXXXX"));
666 exp->pprocq->append (new Emsg (CMSG_WARN, sb));
667 }
668 else if (strcmp (str, SP_JCMD_SAMPLE) == 0)
669 {
670 exp->update_last_event (exp->exp_start_time + ts); // ts is 0-based
671 str = attrs->getValue (NTXT ("id"));
672 int id = str ? atoi (str) : -1;
673 char *label = dbe_strdup (attrs->getValue (NTXT ("label")));
674 exp->process_sample_cmd (NULL, ts, id, label);
675 }
676 else if (strcmp (str, SP_JCMD_EXIT) == 0)
677 {
678 // don't treat EXIT as an event w.r.t. last_event and non_paused_time
679 exp->status = Experiment::SUCCESS;
680 }
681 else if (strcmp (str, SP_JCMD_CERROR) == 0)
682 {
683 mkind = CMSG_ERROR;
684 str = attrs->getValue (NTXT ("id"));
685 if (str != NULL)
686 {
687 mnum = atoi (str);
688 }
689 str = attrs->getValue (NTXT ("ec"));
690 if (str != NULL)
691 {
692 mec = atoi (str);
693 }
694 }
695 else if (strcmp (str, SP_JCMD_CWARN) == 0)
696 {
697 mkind = CMSG_WARN;
698 str = attrs->getValue (NTXT ("id"));
699 if (str != NULL)
700 mnum = atoi (str);
701 }
702 else if (strcmp (str, SP_JCMD_COMMENT) == 0)
703 {
704 mkind = CMSG_COMMENT;
705 str = attrs->getValue (NTXT ("id"));
706 if (str != NULL)
707 mnum = atoi (str);
708 str = attrs->getValue (NTXT ("text"));
709 if (str != NULL)
710 {
711 StringBuilder sb;
712 sb.sprintf (GTXT ("*** Note: %s"), str);
713 exp->commentq->append (new Emsg (CMSG_COMMENT, sb));
714 }
715 }
716 else if (strcmp (str, SP_JCMD_DESC_START) == 0)
717 {
718 char *variant = toStr (attrs, NTXT ("variant"));
719 char *lineage = toStr (attrs, NTXT ("lineage"));
720 int follow = toInt (attrs, NTXT ("follow"));
721 char *msg = toStr (attrs, NTXT ("msg"));
722 exp->process_desc_start_cmd (NULL, ts, variant, lineage, follow, msg);
723 }
724 else if (strcmp (str, SP_JCMD_DESC_STARTED) == 0)
725 {
726 char *variant = toStr (attrs, NTXT ("variant"));
727 char *lineage = toStr (attrs, NTXT ("lineage"));
728 int follow = toInt (attrs, NTXT ("follow"));
729 char *msg = toStr (attrs, NTXT ("msg"));
730 exp->process_desc_started_cmd (NULL, ts, variant, lineage, follow, msg);
731 }
732 else if (strcmp (str, SP_JCMD_EXEC_START) == 0)
733 {
734 // if successful, acts like experiment termination - no "exit" entry will follow
735 exp->update_last_event (exp->exp_start_time + ts); // ts is 0-based
736 char *variant = toStr (attrs, NTXT ("variant"));
737 char *lineage = toStr (attrs, NTXT ("lineage"));
738 int follow = toInt (attrs, NTXT ("follow"));
739 char *msg = toStr (attrs, NTXT ("msg"));
740 exp->process_desc_start_cmd (NULL, ts, variant, lineage, follow, msg);
741 exp->exec_started = true;
742 }
743 else if (strcmp (str, SP_JCMD_EXEC_ERROR) == 0)
744 {
745 exp->update_last_event (exp->exp_start_time + ts); // ts is 0-based
746 char *variant = toStr (attrs, NTXT ("variant"));
747 char *lineage = toStr (attrs, NTXT ("lineage"));
748 int follow = toInt (attrs, NTXT ("follow"));
749 char *msg = toStr (attrs, NTXT ("msg"));
750 exp->process_desc_started_cmd (NULL, ts, variant, lineage, follow, msg);
751 exp->exec_started = false;
752 }
753 else if (strcmp (str, SP_JCMD_JTHRSTART) == 0)
754 {
755 char *name = dbe_strdup (attrs->getValue (NTXT ("name")));
756 char *grpname = dbe_strdup (attrs->getValue (NTXT ("grpname")));
757 char *prntname = dbe_strdup (attrs->getValue (NTXT ("prntname")));
758 str = attrs->getValue (NTXT ("tid"));
759 uint64_t tid = str ? strtoull (str, NULL, 0) : 0;
760 str = attrs->getValue (NTXT ("jthr"));
761 Vaddr jthr = str ? strtoull (str, NULL, 0) : 0;
762 str = attrs->getValue (NTXT ("jenv"));
763 Vaddr jenv = str ? strtoull (str, NULL, 0) : 0;
764 exp->process_jthr_start_cmd (NULL, name, grpname, prntname, tid, jthr, jenv, ts);
765 }
766 else if (strcmp (str, SP_JCMD_JTHREND) == 0)
767 {
768 str = attrs->getValue (NTXT ("tid"));
769 uint64_t tid = str ? strtoull (str, NULL, 0) : 0;
770 str = attrs->getValue (NTXT ("jthr"));
771 Vaddr jthr = str ? strtoull (str, NULL, 0) : 0;
772 str = attrs->getValue (NTXT ("jenv"));
773 Vaddr jenv = str ? strtoull (str, NULL, 0) : 0;
774 exp->process_jthr_end_cmd (NULL, tid, jthr, jenv, ts);
775 }
776 else if (strcmp (str, SP_JCMD_GCEND) == 0)
777 {
778 if (exp->getDataDescriptor (DATA_GCEVENT) == NULL)
779 exp->newDataDescriptor (DATA_GCEVENT);
780 exp->process_gc_end_cmd (ts);
781 }
782 else if (strcmp (str, SP_JCMD_GCSTART) == 0)
783 {
784 if (exp->getDataDescriptor (DATA_GCEVENT) == NULL)
785 exp->newDataDescriptor (DATA_GCEVENT);
786 exp->process_gc_start_cmd (ts);
787 }
788 else if (strcmp (str, SP_JCMD_PAUSE) == 0)
789 {
790 if (exp->resume_ts != MAX_TIME)
791 {
792 // data collection was active
793 hrtime_t delta = ts - exp->resume_ts;
794 exp->non_paused_time += delta;
795 exp->resume_ts = MAX_TIME; // collection is paused
796 }
797 StringBuilder sb;
798 str = attrs->getValue (NTXT ("name"));
799 if (str == NULL)
800 sb.sprintf (GTXT ("Pause: %ld.%09ld"), (long) (ts / NANOSEC),
801 (long) (ts % NANOSEC));
802 else
803 sb.sprintf (GTXT ("Pause (%s): %ld.%09ld"), str,
804 (long) (ts / NANOSEC), (long) (ts % NANOSEC));
805 exp->runlogq->append (new Emsg (CMSG_COMMENT, sb));
806 }
807 else if (strcmp (str, SP_JCMD_RESUME) == 0)
808 {
809 if (exp->resume_ts == MAX_TIME)
810 // data collection was paused
811 exp->resume_ts = ts; // remember start time
812 StringBuilder sb;
813 sb.sprintf (GTXT ("Resume: %ld.%09ld"), (long) (ts / NANOSEC), (long) (ts % NANOSEC));
814 exp->runlogq->append (new Emsg (CMSG_COMMENT, sb));
815 if (exp->exp_start_time == ZERO_TIME)
816 exp->exp_start_time = ts;
817 }
818 else if (strcmp (str, SP_JCMD_THREAD_PAUSE) == 0)
819 {
820 str = attrs->getValue (NTXT ("tid"));
821 uint64_t tid = str ? strtoull (str, NULL, 0) : 0;
822 StringBuilder sb;
823 sb.sprintf (GTXT ("Thread %llu pause: %ld.%09ld"), (unsigned long long) tid,
824 (long) (ts / NANOSEC), (long) (ts % NANOSEC));
825 exp->runlogq->append (new Emsg (CMSG_COMMENT, sb));
826 }
827 else if (strcmp (str, SP_JCMD_THREAD_RESUME) == 0)
828 {
829 str = attrs->getValue (NTXT ("tid"));
830 uint64_t tid = str ? strtoull (str, NULL, 0) : 0;
831 StringBuilder sb;
832 sb.sprintf (GTXT ("Thread %llu resume: %ld.%09ld"), (unsigned long long) tid,
833 (long) (ts / NANOSEC), (long) (ts % NANOSEC));
834 exp->runlogq->append (new Emsg (CMSG_COMMENT, sb));
835 }
836 else if (strcmp (str, NTXT ("map")) == 0)
837 {
838 ts += exp->exp_start_time;
839 str = attrs->getValue (NTXT ("vaddr"));
840 Vaddr vaddr = str ? strtoull (str, NULL, 0) : 0;
841 str = attrs->getValue (NTXT ("size"));
842 int msize = str ? atoi (str) : 0;
843 str = attrs->getValue (NTXT ("foffset"));
844 int64_t offset = str ? strtoll (str, NULL, 0) : 0;
845 str = attrs->getValue (NTXT ("modes"));
846 int64_t modes = str ? strtoll (str, NULL, 0) : 0;
847 str = attrs->getValue (NTXT ("chksum"));
848 int64_t chksum = 0;
849 if (str)
850 chksum = Elf::normalize_checksum (strtoll (str, NULL, 0));
851 char *name = (char *) attrs->getValue (NTXT ("name"));
852 str = attrs->getValue (NTXT ("object"));
853 if (strcmp (str, NTXT ("segment")) == 0)
854 {
855 if (strcmp (name, NTXT ("LinuxKernel")) == 0)
856 exp->process_Linux_kernel_cmd (ts);
857 else
858 exp->process_seg_map_cmd (NULL, ts, vaddr, msize, 0,
859 offset, modes, chksum, name);
860 }
861 else if (strcmp (str, NTXT ("function")) == 0)
862 {
863 exp->process_fn_load_cmd (dynfuncModule, name, vaddr, msize, ts);
864 dynfuncModule = NULL;
865 }
866 else if (strcmp (str, NTXT ("dynfunc")) == 0)
867 {
868 if (dynfuncModule == NULL)
869 {
870 dynfuncModule = dbeSession->createModule (exp->get_dynfunc_lo (DYNFUNC_SEGMENT), name);
871 dynfuncModule->flags |= MOD_FLAG_UNKNOWN;
872 dynfuncModule->set_file_name (dbe_strdup (dynfuncModule->getMainSrc ()->get_name ()));
873 }
874 (void) exp->create_dynfunc (dynfuncModule,
875 (char*) attrs->getValue (NTXT ("funcname")), vaddr, msize);
876 }
877 else if (strcmp (str, NTXT ("jcm")) == 0)
878 {
879 str = attrs->getValue (NTXT ("methodId"));
880 Vaddr mid = str ? strtoull (str, NULL, 0) : 0;
881 exp->process_jcm_load_cmd (NULL, mid, vaddr, msize, ts);
882 }
883 }
884 else if (strcmp (str, NTXT ("unmap")) == 0)
885 {
886 ts += exp->exp_start_time;
887 str = attrs->getValue (NTXT ("vaddr"));
888 Vaddr vaddr = str ? strtoull (str, NULL, 0) : 0;
889 exp->process_seg_unmap_cmd (NULL, ts, vaddr);
890 }
891 }
892 // end of code for event
893 }
894 else if (strcmp (qName, SP_TAG_PROFILE) == 0)
895 {
896 pushElem (EL_PROFILE);
897 const char *str = attrs->getValue (NTXT ("name"));
898 if (str == NULL)
899 return;
900 if (strcmp (str, NTXT ("profile")) == 0)
901 {
902 exp->coll_params.profile_mode = 1;
903 str = attrs->getValue (NTXT ("numstates"));
904 if (str != NULL)
905 exp->coll_params.lms_magic_id = atoi (str);
906 str = attrs->getValue (NTXT ("ptimer"));
907 if (str != NULL)
908 exp->coll_params.ptimer_usec = atoi (str); // microseconds
909
910 PropDescr *mstate_prop = NULL;
911 char * stateNames [/*LMS_NUM_STATES*/] = LMS_STATE_STRINGS;
912 char * stateUNames[/*LMS_NUM_STATES*/] = LMS_STATE_USTRINGS;
913 {
914 dDscr = exp->newDataDescriptor (DATA_CLOCK);
915 PropDescr *prop = new PropDescr (PROP_MSTATE, NTXT ("MSTATE"));
916 prop->uname = dbe_strdup (GTXT ("Thread state"));
917 prop->vtype = TYPE_UINT32;
918 // (states added below)
919 dDscr->addProperty (prop);
920 mstate_prop = prop;
921
922 prop = new PropDescr (PROP_NTICK, NTXT ("NTICK"));
923 prop->uname = dbe_strdup (GTXT ("Number of Profiling Ticks"));
924 prop->vtype = TYPE_UINT32;
925 dDscr->addProperty (prop);
926 }
927
928 switch (exp->coll_params.lms_magic_id)
929 {
930 case LMS_MAGIC_ID_SOLARIS:
931 exp->register_metric (Metric::CP_TOTAL);
932 exp->register_metric (Metric::CP_TOTAL_CPU);
933 exp->register_metric (Metric::CP_LMS_USER);
934 exp->register_metric (Metric::CP_LMS_SYSTEM);
935 exp->register_metric (Metric::CP_LMS_TRAP);
936 exp->register_metric (Metric::CP_LMS_DFAULT);
937 exp->register_metric (Metric::CP_LMS_TFAULT);
938 exp->register_metric (Metric::CP_LMS_KFAULT);
939 exp->register_metric (Metric::CP_LMS_STOPPED);
940 exp->register_metric (Metric::CP_LMS_WAIT_CPU);
941 exp->register_metric (Metric::CP_LMS_SLEEP);
942 exp->register_metric (Metric::CP_LMS_USER_LOCK);
943 for (int ii = 0; ii < LMS_NUM_SOLARIS_MSTATES; ii++)
944 mstate_prop->addState (ii, stateNames[ii], stateUNames[ii]);
945 break;
946 case LMS_MAGIC_ID_ERKERNEL_KERNEL:
947 exp->register_metric (Metric::CP_KERNEL_CPU);
948 {
949 int ii = LMS_KERNEL_CPU;
950 mstate_prop->addState (ii, stateNames[ii], stateUNames[ii]);
951 }
952 break;
953 case LMS_MAGIC_ID_ERKERNEL_USER:
954 exp->register_metric (Metric::CP_TOTAL_CPU);
955 exp->register_metric (Metric::CP_LMS_USER);
956 exp->register_metric (Metric::CP_LMS_SYSTEM);
957 {
958 int ii = LMS_KERNEL_CPU;
959 mstate_prop->addState (ii, stateNames[ii], stateUNames[ii]);
960 ii = LMS_USER;
961 mstate_prop->addState (ii, stateNames[ii], stateUNames[ii]);
962 ii = LMS_SYSTEM;
963 mstate_prop->addState (ii, stateNames[ii], stateUNames[ii]);
964 }
965 break;
966 case LMS_MAGIC_ID_LINUX:
967 exp->register_metric (Metric::CP_TOTAL_CPU);
968 {
969 int ii = LMS_LINUX_CPU;
970 mstate_prop->addState (ii, stateNames[ii], stateUNames[ii]);
971 }
972 break;
973 default:
974 // odd
975 break;
976 }
977 }
978 else if (strcmp (str, NTXT ("heaptrace")) == 0)
979 {
980 exp->coll_params.heap_mode = 1;
981 exp->leaklistavail = true;
982 exp->heapdataavail = true;
983 exp->register_metric (Metric::HEAP_ALLOC_BYTES);
984 exp->register_metric (Metric::HEAP_ALLOC_CNT);
985 exp->register_metric (Metric::HEAP_LEAK_BYTES);
986 exp->register_metric (Metric::HEAP_LEAK_CNT);
987 dDscr = exp->newDataDescriptor (DATA_HEAP);
988 }
989 else if (strcmp (str, NTXT ("iotrace")) == 0)
990 {
991 exp->coll_params.io_mode = 1;
992 exp->iodataavail = true;
993 exp->register_metric (Metric::IO_READ_TIME);
994 exp->register_metric (Metric::IO_READ_BYTES);
995 exp->register_metric (Metric::IO_READ_CNT);
996 exp->register_metric (Metric::IO_WRITE_TIME);
997 exp->register_metric (Metric::IO_WRITE_BYTES);
998 exp->register_metric (Metric::IO_WRITE_CNT);
999 exp->register_metric (Metric::IO_OTHER_TIME);
1000 exp->register_metric (Metric::IO_OTHER_CNT);
1001 exp->register_metric (Metric::IO_ERROR_TIME);
1002 exp->register_metric (Metric::IO_ERROR_CNT);
1003 dDscr = exp->newDataDescriptor (DATA_IOTRACE);
1004 }
1005 else if (strcmp (str, NTXT ("synctrace")) == 0)
1006 {
1007 exp->coll_params.sync_mode = 1;
1008 str = attrs->getValue (NTXT ("threshold"));
1009 if (str != NULL)
1010 exp->coll_params.sync_threshold = atoi (str);
1011 str = attrs->getValue (NTXT ("scope"));
1012 if (str != NULL)
1013 exp->coll_params.sync_scope = atoi (str);
1014 else // Should only happen with old experiments; use the old default
1015 exp->coll_params.sync_scope = SYNCSCOPE_NATIVE | SYNCSCOPE_JAVA;
1016 exp->register_metric (Metric::SYNC_WAIT_TIME);
1017 exp->register_metric (Metric::SYNC_WAIT_COUNT);
1018 dDscr = exp->newDataDescriptor (DATA_SYNCH);
1019 }
1020 else if (strcmp (str, NTXT ("omptrace")) == 0)
1021 {
1022 exp->coll_params.omp_mode = 1;
1023 dDscr = exp->newDataDescriptor (DATA_OMP, DDFLAG_NOSHOW);
1024 }
1025 else if (strcmp (str, NTXT ("hwcounter")) == 0)
1026 {
1027 str = attrs->getValue (NTXT ("cpuver"));
1028 int cpuver = str ? atoi (str) : 0;
1029 char *counter = dbe_strdup (attrs->getValue (NTXT ("hwcname")));
1030 char *int_name = dbe_strdup (attrs->getValue (NTXT ("int_name"))); // may not be present
1031 str = attrs->getValue (NTXT ("interval"));
1032 int interval = str ? atoi (str) : 0;
1033 str = attrs->getValue (NTXT ("tag"));
1034 int tag = str ? atoi (str) : 0;
1035 str = attrs->getValue (NTXT ("memop"));
1036 int i_tpc = str ? atoi (str) : 0;
1037 char *modstr = dbe_strdup (attrs->getValue (NTXT ("modstr")));
1038 exp->process_hwcounter_cmd (NULL, cpuver, counter, int_name, interval, tag, i_tpc, modstr);
1039 dDscr = exp->newDataDescriptor (DATA_HWC);
1040 }
1041 else if (strcmp (str, NTXT ("hwsimctr")) == 0)
1042 {
1043 int cpuver = toInt (attrs, NTXT ("cpuver"));
1044 char *hwcname = dbe_strdup (attrs->getValue (NTXT ("hwcname")));
1045 char *int_name = dbe_strdup (attrs->getValue (NTXT ("int_name")));
1046 char *metric = dbe_strdup (attrs->getValue (NTXT ("metric")));
1047 int reg = toInt (attrs, NTXT ("reg_num"));
1048 int interval = toInt (attrs, NTXT ("interval"));
1049 int timecvt = toInt (attrs, NTXT ("timecvt"));
1050 int i_tpc = toInt (attrs, NTXT ("memop"));
1051 int tag = toInt (attrs, NTXT ("tag"));
1052 exp->process_hwsimctr_cmd (NULL, cpuver, hwcname, int_name, metric, reg,
1053 interval, timecvt, i_tpc, tag);
1054 dDscr = exp->newDataDescriptor (DATA_HWC);
1055 }
1056 else if (strcmp (str, NTXT ("dversion")) == 0)
1057 exp->dversion = dbe_strdup (attrs->getValue (NTXT ("version")));
1058 else if (strcmp (str, NTXT ("jprofile")) == 0)
1059 {
1060 exp->has_java = true;
1061 str = attrs->getValue (NTXT ("jversion"));
1062 if (str != NULL)
1063 exp->jversion = strdup (str);
1064 }
1065 else if (strcmp (str, NTXT ("datarace")) == 0)
1066 {
1067 exp->coll_params.race_mode = 1;
1068 exp->racelistavail = true;
1069 str = attrs->getValue (NTXT ("scheme"));
1070 exp->coll_params.race_stack = str ? atoi (str) : 0;
1071 exp->register_metric (Metric::RACCESS);
1072 dDscr = exp->newDataDescriptor (DATA_RACE);
1073 }
1074 else if (strcmp (str, NTXT ("deadlock")) == 0)
1075 {
1076 exp->coll_params.deadlock_mode = 1;
1077 exp->deadlocklistavail = true;
1078 exp->register_metric (Metric::DEADLOCKS);
1079 dDscr = exp->newDataDescriptor (DATA_DLCK);
1080 }
1081 }
1082 /* XXX -- obsolete tag, but is still written to experiments */
1083 else if (strcmp (qName, SP_TAG_DATAPTR) == 0)
1084 {
1085 pushElem (EL_DATAPTR);
1086 return;
1087 }
1088 else if (strcmp (qName, SP_TAG_PROFDATA) == 0)
1089 {
1090 pushElem (EL_PROFDATA);
1091 // SS12 HWC experiments are not well structured
1092 const char *fname = attrs->getValue (NTXT ("fname"));
1093 if (fname && strcmp (fname, SP_HWCNTR_FILE) == 0)
1094 dDscr = exp->newDataDescriptor (DATA_HWC);
1095 }
1096 else if (strcmp (qName, SP_TAG_PROFPCKT) == 0)
1097 {
1098 pushElem (EL_PROFPCKT);
1099 const char *str = attrs->getValue (NTXT ("kind")); // see Pckt_type
1100 int kind = str ? atoi (str) : -1;
1101 if (kind < 0)
1102 return;
1103 if (exp->coll_params.omp_mode == 1)
1104 {
1105 if (kind == OMP_PCKT)
1106 dDscr = exp->newDataDescriptor (DATA_OMP, DDFLAG_NOSHOW);
1107 else if (kind == OMP2_PCKT)
1108 dDscr = exp->newDataDescriptor (DATA_OMP2, DDFLAG_NOSHOW);
1109 else if (kind == OMP3_PCKT)
1110 dDscr = exp->newDataDescriptor (DATA_OMP3, DDFLAG_NOSHOW);
1111 else if (kind == OMP4_PCKT)
1112 dDscr = exp->newDataDescriptor (DATA_OMP4, DDFLAG_NOSHOW);
1113 else if (kind == OMP5_PCKT)
1114 dDscr = exp->newDataDescriptor (DATA_OMP5, DDFLAG_NOSHOW);
1115 }
1116 pDscr = exp->newPacketDescriptor (kind, dDscr);
1117 return;
1118 }
1119 else if (strcmp (qName, SP_TAG_FIELD) == 0)
1120 {
1121 pushElem (EL_FIELD);
1122 if (pDscr != NULL)
1123 {
1124 const char *name = attrs->getValue (NTXT ("name"));
1125 if (name == NULL)
1126 return;
1127 int propID = dbeSession->registerPropertyName (name);
1128 propDscr = new PropDescr (propID, name);
1129 FieldDescr *fldDscr = new FieldDescr (propID, name);
1130
1131 const char *str = attrs->getValue (NTXT ("type"));
1132 if (str)
1133 {
1134 if (strcmp (str, NTXT ("INT32")) == 0)
1135 fldDscr->vtype = TYPE_INT32;
1136 else if (strcmp (str, NTXT ("UINT32")) == 0)
1137 fldDscr->vtype = TYPE_UINT32;
1138 else if (strcmp (str, NTXT ("INT64")) == 0)
1139 fldDscr->vtype = TYPE_INT64;
1140 else if (strcmp (str, NTXT ("UINT64")) == 0)
1141 fldDscr->vtype = TYPE_UINT64;
1142 else if (strcmp (str, NTXT ("STRING")) == 0)
1143 fldDscr->vtype = TYPE_STRING;
1144 else if (strcmp (str, NTXT ("DOUBLE")) == 0)
1145 fldDscr->vtype = TYPE_DOUBLE;
1146 else if (strcmp (str, NTXT ("DATE")) == 0)
1147 {
1148 fldDscr->vtype = TYPE_DATE;
1149 const char *fmt = attrs->getValue (NTXT ("format"));
1150 fldDscr->format = strdup (fmt ? fmt : "");
1151 }
1152 }
1153 propDscr->vtype = fldDscr->vtype;
1154
1155 // TYPE_DATE is converted to TYPE_UINT64 in propDscr
1156 if (fldDscr->vtype == TYPE_DATE)
1157 propDscr->vtype = TYPE_UINT64;
1158
1159 // Fix some types until they are fixed in libcollector
1160 if (propID == PROP_VIRTPC || propID == PROP_PHYSPC)
1161 {
1162 if (fldDscr->vtype == TYPE_INT32)
1163 propDscr->vtype = TYPE_UINT32;
1164 else if (fldDscr->vtype == TYPE_INT64)
1165 propDscr->vtype = TYPE_UINT64;
1166 }
1167
1168 // The following props get mapped to 32-bit values in readPacket
1169 if (propID == PROP_CPUID || propID == PROP_THRID
1170 || propID == PROP_LWPID)
1171 propDscr->vtype = TYPE_UINT32; // override experiment property
1172
1173 str = attrs->getValue (NTXT ("uname"));
1174 if (str)
1175 propDscr->uname = strdup (PTXT ((char*) str));
1176 str = attrs->getValue (NTXT ("noshow"));
1177 if (str && atoi (str) != 0)
1178 propDscr->flags |= PRFLAG_NOSHOW;
1179
1180 if (dDscr == NULL)
1181 {
1182 StringBuilder sb;
1183 sb.sprintf (GTXT ("*** Error: data parsing failed. Log file is corrupted."));
1184 exp->warnq->append (new Emsg (CMSG_ERROR, sb));
1185 throw new SAXException (sb.toString ());
1186 }
1187
1188 dDscr->addProperty (propDscr);
1189 str = attrs->getValue (NTXT ("offset"));
1190 if (str)
1191 fldDscr->offset = atoi (str);
1192 pDscr->addField (fldDscr);
1193 }
1194 }
1195 else if (strcmp (qName, SP_TAG_STATE) == 0)
1196 {
1197 pushElem (EL_STATE);
1198 if (propDscr != NULL)
1199 {
1200 const char *str = attrs->getValue (NTXT ("value"));
1201 int value = str ? atoi (str) : -1;
1202 str = attrs->getValue (NTXT ("name"));
1203 const char *ustr = attrs->getValue (NTXT ("uname"));
1204 propDscr->addState (value, str, ustr);
1205 }
1206 }
1207 else if (strcmp (qName, SP_TAG_DTRACEFATAL) == 0)
1208 pushElem (EL_DTRACEFATAL);
1209 else
1210 {
1211 StringBuilder sb;
1212 sb.sprintf (GTXT ("*** Warning: unrecognized element %s"), qName);
1213 exp->warnq->append (new Emsg (CMSG_WARN, sb));
1214 pushElem (EL_NONE);
1215 }
1216 }
1217
1218 void
1219 Experiment::ExperimentHandler::characters (char *ch, int start, int length)
1220 {
1221 switch (curElem)
1222 {
1223 case EL_COLLECTOR:
1224 exp->cversion = dbe_strndup (ch + start, length);
1225 break;
1226 case EL_PROCESS:
1227 exp->process_arglist_cmd (NULL, dbe_strndup (ch + start, length));
1228 break;
1229 case EL_EVENT:
1230 free (text);
1231 text = dbe_strndup (ch + start, length);
1232 break;
1233 default:
1234 break;
1235 }
1236 }
1237
1238 void
1239 Experiment::ExperimentHandler::endElement (char*, char*, char*)
1240 {
1241 if (curElem == EL_EVENT && mkind >= 0 && mnum >= 0)
1242 {
1243 char *str;
1244 if (mec > 0)
1245 str = dbe_sprintf ("%s -- %s", text != NULL ? text : "", strerror (mec));
1246 else
1247 str = dbe_sprintf ("%s", text != NULL ? text : "");
1248 Emsg *msg = new Emsg (mkind, mnum, str);
1249 if (mkind == CMSG_WARN)
1250 {
1251 if (mnum != COL_WARN_FSTYPE
1252 || dbeSession->check_ignore_fs_warn () == false)
1253 exp->warnq->append (msg);
1254 else
1255 exp->commentq->append (msg);
1256 }
1257 else if (mkind == CMSG_ERROR || mkind == CMSG_FATAL)
1258 exp->errorq->append (msg);
1259 else if (mkind == CMSG_COMMENT)
1260 exp->commentq->append (msg);
1261 else
1262 delete msg;
1263 mkind = (Cmsg_warn) - 1;
1264 mnum = -1;
1265 mec = -1;
1266 }
1267 else if (curElem == EL_PROFILE)
1268 dDscr = NULL;
1269 else if (curElem == EL_PROFPCKT)
1270 pDscr = NULL;
1271 else if (curElem == EL_FIELD)
1272 propDscr = NULL;
1273 free (text);
1274 text = NULL;
1275 popElem ();
1276 }
1277
1278 void
1279 Experiment::ExperimentHandler::error (SAXParseException *e)
1280 {
1281 StringBuilder sb;
1282 sb.sprintf (GTXT ("%s at line %d, column %d"),
1283 e->getMessage (), e->getLineNumber (), e->getColumnNumber ());
1284 char *msg = sb.toString ();
1285 SAXException *e1 = new SAXException (msg);
1286 free (msg);
1287 throw ( e1);
1288 }
1289
1290 //-------------------------------------------------- Experiment
1291
1292 Experiment::Experiment ()
1293 {
1294 groupId = 0;
1295 userExpId = expIdx = -1;
1296 founder_exp = NULL;
1297 baseFounder = NULL;
1298 children_exps = new Vector<Experiment*>;
1299 loadObjs = new Vector<LoadObject*>;
1300 loadObjMap = new StringMap<LoadObject*>(128, 128);
1301 sourcesMap = NULL;
1302
1303 // Initialize configuration information.
1304 status = FAILURE;
1305 start_sec = 0;
1306 mtime = 0;
1307 hostname = NULL;
1308 username = NULL;
1309 architecture = NULL;
1310 os_version = NULL;
1311 uarglist = NULL;
1312 utargname = NULL;
1313 ucwd = NULL;
1314 cversion = NULL;
1315 dversion = NULL;
1316 jversion = NULL;
1317 exp_maj_version = 0;
1318 exp_min_version = 0;
1319 platform = Unknown;
1320 wsize = Wnone;
1321 page_size = 4096;
1322 npages = 0;
1323 stack_base = 0xf0000000;
1324 broken = 1;
1325 obsolete = 0;
1326 hwc_bogus = 0;
1327 hwc_lost_int = 0;
1328 hwc_scanned = 0;
1329 hwc_default = false;
1330 invalid_packet = 0;
1331
1332 // clear HWC event stats
1333 dsevents = 0;
1334 dsnoxhwcevents = 0;
1335
1336 memset (&coll_params, 0, sizeof (coll_params));
1337 ncpus = 0;
1338 minclock = 0;
1339 maxclock = 0;
1340 clock = 0;
1341 varclock = 0;
1342 exec_started = false;
1343 timelineavail = true;
1344 leaklistavail = false;
1345 heapdataavail = false;
1346 iodataavail = false;
1347 dataspaceavail = false;
1348 ifreqavail = false;
1349 racelistavail = false;
1350 deadlocklistavail = false;
1351 ompavail = false;
1352 tiny_threshold = -1;
1353 pid = 0;
1354 ppid = 0;
1355 pgrp = 0;
1356 sid = 0;
1357
1358 gc_duration = ZERO_TIME;
1359 exp_start_time = ZERO_TIME; // not known. Wall-clock hrtime (not zero based)
1360 last_event = ZERO_TIME; // not known. Wall-clock hrtime (not zero based)
1361 non_paused_time = 0; // 0 non-paused time (will sum as experiment is processed)
1362 resume_ts = 0; // by default, collection is "resumed" (not paused) from time=0
1363 need_swap_endian = false;
1364 exp_rel_start_time_set = false;
1365 exp_rel_start_time = ZERO_TIME;
1366 has_java = false;
1367 hex_field_width = 8;
1368 hw_cpuver = CPUVER_UNDEFINED;
1369 machinemodel = NULL;
1370 expt_name = NULL;
1371 arch_name = NULL;
1372 fndr_arch_name = NULL;
1373 dyntext_name = NULL;
1374 logFile = NULL;
1375
1376 dataDscrs = new Vector<DataDescriptor*>;
1377 for (int i = 0; i < DATA_LAST; ++i)
1378 dataDscrs->append (NULL);
1379
1380 pcktDscrs = new Vector<PacketDescriptor*>;
1381 blksz = PROFILE_BUFFER_CHUNK;
1382 jthreads = new Vector<JThread*>;
1383 jthreads_idx = new Vector<JThread*>;
1384 gcevents = new Vector<GCEvent*>;
1385 gcevent_last_used = (GCEvent *) NULL;
1386 heapUnmapEvents = new Vector<UnmapChunk*>;
1387 cstack = NULL;
1388 cstackShowHide = NULL;
1389 frmpckts = new Vector<RawFramePacket*>;
1390 typedef DefaultMap2D<uint32_t, hrtime_t, uint64_t> OmpMap0;
1391 mapPRid = new OmpMap0 (OmpMap0::Interval);
1392 typedef DefaultMap2D<uint32_t, hrtime_t, void*> OmpMap;
1393 mapPReg = new OmpMap (OmpMap::Interval);
1394 mapTask = new OmpMap (OmpMap::Interval);
1395 openMPdata = NULL;
1396 archiveMap = NULL;
1397 nnodes = 0;
1398 nchunks = 0;
1399 chunks = 0;
1400 uidHTable = NULL;
1401 uidnodes = new Vector<UIDnode*>;
1402 mrecs = new Vector<MapRecord*>;
1403 samples = new Vector<Sample*>;
1404 sample_last_used = (Sample *) NULL;
1405 first_sample_label = (char*) NULL;
1406 fDataMap = NULL;
1407 vFdMap = NULL;
1408 resolveFrameInfo = true;
1409 discardTiny = false;
1410 init ();
1411 }
1412
1413 Experiment::~Experiment ()
1414 {
1415 fini ();
1416 free (coll_params.linetrace);
1417 for (int i = 0; i < MAX_HWCOUNT; i++)
1418 {
1419 free (coll_params.hw_aux_name[i]);
1420 free (coll_params.hw_username[i]);
1421 }
1422 free (hostname);
1423 free (username);
1424 free (architecture);
1425 free (os_version);
1426 free (uarglist);
1427 free (utargname);
1428 free (ucwd);
1429 free (cversion);
1430 free (dversion);
1431 free (jversion);
1432 delete logFile;
1433 free (expt_name);
1434 free (arch_name);
1435 free (fndr_arch_name);
1436 free (dyntext_name);
1437 delete jthreads_idx;
1438 delete cstack;
1439 delete cstackShowHide;
1440 delete mapPRid;
1441 delete mapPReg;
1442 delete mapTask;
1443 delete openMPdata;
1444 destroy_map (DbeFile *, archiveMap);
1445 delete[] uidHTable;
1446 delete uidnodes;
1447 delete mrecs;
1448 delete children_exps;
1449 delete loadObjs;
1450 delete loadObjMap;
1451 delete sourcesMap;
1452 free (first_sample_label);
1453 free (machinemodel);
1454
1455 dataDscrs->destroy ();
1456 delete dataDscrs;
1457 pcktDscrs->destroy ();
1458 delete pcktDscrs;
1459 jthreads->destroy ();
1460 delete jthreads;
1461 gcevents->destroy ();
1462 delete gcevents;
1463 heapUnmapEvents->destroy ();
1464 delete heapUnmapEvents;
1465 frmpckts->destroy ();
1466 delete frmpckts;
1467 samples->destroy ();
1468 delete samples;
1469 delete fDataMap;
1470 delete vFdMap;
1471
1472 for (long i = 0; i < nchunks; i++)
1473 delete[] chunks[i];
1474 delete[] chunks;
1475 }
1476
1477 void
1478 Experiment::init_cache ()
1479 {
1480 if (smemHTable)
1481 return;
1482 smemHTable = new SegMem*[HTableSize];
1483 instHTable = new DbeInstr*[HTableSize];
1484 for (int i = 0; i < HTableSize; i++)
1485 {
1486 smemHTable[i] = NULL;
1487 instHTable[i] = NULL;
1488 }
1489 uidHTable = new UIDnode*[HTableSize];
1490 for (int i = 0; i < HTableSize; i++)
1491 uidHTable[i] = NULL;
1492
1493 cstack = CallStack::getInstance (this);
1494 cstackShowHide = CallStack::getInstance (this);
1495 }
1496
1497 void
1498 Experiment::init ()
1499 {
1500 userLabels = NULL;
1501 seg_items = new Vector<SegMem*>;
1502 maps = new PRBTree ();
1503 jmaps = NULL; // used by JAVA_CLASSES only
1504 jmidHTable = NULL;
1505 smemHTable = NULL;
1506 instHTable = NULL;
1507 min_thread = (uint64_t) - 1;
1508 max_thread = 0;
1509 thread_cnt = 0;
1510 min_lwp = (uint64_t) - 1;
1511 max_lwp = 0;
1512 lwp_cnt = 0;
1513 min_cpu = (uint64_t) - 1;
1514 max_cpu = 0;
1515 cpu_cnt = 0;
1516
1517 commentq = new Emsgqueue (NTXT ("commentq"));
1518 runlogq = new Emsgqueue (NTXT ("runlogq"));
1519 errorq = new Emsgqueue (NTXT ("errorq"));
1520 warnq = new Emsgqueue (NTXT ("warnq"));
1521 notesq = new Emsgqueue (NTXT ("notesq"));
1522 pprocq = new Emsgqueue (NTXT ("pprocq"));
1523 ifreqq = NULL;
1524
1525 metrics = new Vector<BaseMetric*>;
1526 tagObjs = new Vector<Vector<Histable*>*>;
1527 tagObjs->store (PROP_THRID, new Vector<Histable*>);
1528 tagObjs->store (PROP_LWPID, new Vector<Histable*>);
1529 tagObjs->store (PROP_CPUID, new Vector<Histable*>);
1530 tagObjs->store (PROP_EXPID, new Vector<Histable*>);
1531 sparse_threads = false;
1532 }
1533
1534 void
1535 Experiment::fini ()
1536 {
1537 seg_items->destroy ();
1538 delete seg_items;
1539 delete maps;
1540 delete jmaps;
1541 delete[] smemHTable;
1542 delete[] instHTable;
1543 delete jmidHTable;
1544 delete commentq;
1545 delete runlogq;
1546 delete errorq;
1547 delete warnq;
1548 delete notesq;
1549 delete pprocq;
1550 if (ifreqq != NULL)
1551 {
1552 delete ifreqq;
1553 ifreqq = NULL;
1554 }
1555
1556 int index;
1557 BaseMetric *mtr;
1558 Vec_loop (BaseMetric*, metrics, index, mtr)
1559 {
1560 dbeSession->drop_metric (mtr);
1561 }
1562 delete metrics;
1563 tagObjs->fetch (PROP_THRID)->destroy ();
1564 tagObjs->fetch (PROP_LWPID)->destroy ();
1565 tagObjs->fetch (PROP_CPUID)->destroy ();
1566 tagObjs->fetch (PROP_EXPID)->destroy ();
1567 tagObjs->destroy ();
1568 delete tagObjs;
1569 }
1570
1571 // These are the data files which can be read in parallel
1572 // for multiple sub-experiments.
1573 // Postpone calling resolve_frame_info()
1574 void
1575 Experiment::read_experiment_data (bool read_ahead)
1576 {
1577
1578 read_frameinfo_file ();
1579 if (read_ahead)
1580 {
1581 resolveFrameInfo = false;
1582 (void) get_profile_events ();
1583 resolveFrameInfo = true;
1584 }
1585 }
1586
1587 Experiment::Exp_status
1588 Experiment::open_epilogue ()
1589 {
1590
1591 // set up mapping for tagObj(PROP_EXPID)
1592 (void) mapTagValue (PROP_EXPID, userExpId);
1593
1594 post_process ();
1595 if (last_event != ZERO_TIME)
1596 { // if last_event is known
1597 StringBuilder sb;
1598 hrtime_t ts = last_event - exp_start_time;
1599 sb.sprintf (GTXT ("Experiment Ended: %ld.%09ld\nData Collection Duration: %ld.%09ld"),
1600 (long) (ts / NANOSEC), (long) (ts % NANOSEC),
1601 (long) (non_paused_time / NANOSEC),
1602 (long) (non_paused_time % NANOSEC));
1603 runlogq->append (new Emsg (CMSG_COMMENT, sb));
1604 }
1605
1606 // Check for incomplete experiment, and inform the user
1607 if (status == INCOMPLETE)
1608 {
1609 if (exec_started == true)
1610 // experiment ended with the exec, not abnormally
1611 status = SUCCESS;
1612 else
1613 {
1614 char * cmnt = GTXT ("*** Note: experiment was not closed");
1615 commentq->append (new Emsg (CMSG_COMMENT, cmnt));
1616 // runlogq->append(new Emsg(CMSG_COMMENT, cmnt));
1617 }
1618 }
1619 // write a descriptive header for the experiment
1620 write_header ();
1621 return status;
1622 }
1623
1624 Experiment::Exp_status
1625 Experiment::open (char *path)
1626 {
1627
1628 // Find experiment directory
1629 if (find_expdir (path) != SUCCESS)
1630 // message will have been queued and status set
1631 return status;
1632
1633 // Get creation time for experiment
1634 dbe_stat_t st;
1635 if (dbe_stat (path, &st) == 0)
1636 mtime = st.st_mtime;
1637
1638 // Read the warnings file
1639 read_warn_file ();
1640
1641 // Open the log file
1642 read_log_file ();
1643 if (status == SUCCESS && last_event // last event is initialized
1644 && (last_event - exp_start_time) / 1000000 < tiny_threshold)
1645 {
1646 // Process "tiny_threshold" (SP_ANALYZER_DISCARD_TINY_EXPERIMENTS)
1647 // At this point, we've only processed log.xml.
1648 // Note: if an experiment terminated abnormally, last_event will not yet
1649 // represent events from clock profiling and other metrics.
1650 // Other events will often have timestamps after the last log.xml entry.
1651 discardTiny = true;
1652 return status;
1653 }
1654 if (status == FAILURE)
1655 {
1656 if (logFile->get_status () == ExperimentFile::EF_FAILURE)
1657 {
1658 Emsg *m = new Emsg (CMSG_FATAL, GTXT ("*** Error: log file in experiment cannot be read"));
1659 errorq->append (m);
1660 }
1661 else if (fetch_errors () == NULL)
1662 {
1663 if (broken == 1)
1664 {
1665 Emsg *m = new Emsg (CMSG_FATAL, GTXT ("*** Error: log does not show target starting"));
1666 errorq->append (m);
1667 }
1668 else
1669 {
1670 Emsg *m = new Emsg (CMSG_FATAL, GTXT ("*** Error: log file in experiment could not be parsed"));
1671 errorq->append (m);
1672 }
1673 }
1674 return status;
1675 }
1676 init_cache ();
1677 if (varclock != 0)
1678 {
1679 StringBuilder sb;
1680 sb.sprintf (
1681 GTXT ("*** Warning: system has variable clock frequency, which may cause variable execution times and inaccurate conversions of cycle counts into time."));
1682 warnq->append (new Emsg (CMSG_WARN, sb));
1683 }
1684
1685 // Read the notes file
1686 read_notes_file ();
1687 read_labels_file ();
1688 read_archives ();
1689
1690 // The log file shows experiment started
1691 read_java_classes_file ();
1692
1693 read_map_file ();
1694
1695 // Dyntext file has to be processed after loadobjects file
1696 // as we need to be able to map (vaddr,ts) to dynamic functions.
1697 read_dyntext_file ();
1698
1699 // Read the overview file and create samples.
1700 // Profiling data hasn't been read yet so we may have
1701 // events after the last recorded sample.
1702 // We'll create a fake sample to cover all those
1703 // events later.
1704 read_overview_file ();
1705
1706 // Check if instruction frequency data is available
1707 read_ifreq_file ();
1708
1709 // Check if OMP data is available
1710 read_omp_file ();
1711
1712 return status;
1713 }
1714
1715 /* XXX -- update() is a no-op now, but may be needed for auto-update */
1716 Experiment::Exp_status
1717 Experiment::update ()
1718 {
1719 return status;
1720 }
1721
1722 void
1723 Experiment::append (LoadObject *lo)
1724 {
1725 loadObjs->append (lo);
1726 char *obj_name = lo->get_pathname ();
1727 char *bname = get_basename (obj_name);
1728 loadObjMap->put (obj_name, lo);
1729 loadObjMap->put (bname, lo);
1730 if (lo->flags & SEG_FLAG_EXE)
1731 loadObjMap->put (COMP_EXE_NAME, lo);
1732 }
1733
1734 void
1735 Experiment::read_notes_file ()
1736 {
1737 Emsg *m;
1738
1739 // Open log file:
1740 char *fname = dbe_sprintf (NTXT ("%s/%s"), expt_name, SP_NOTES_FILE);
1741 FILE *f = fopen (fname, NTXT ("r"));
1742 free (fname);
1743 if (f == NULL)
1744 return;
1745 if (!dbeSession->is_interactive ())
1746 {
1747 m = new Emsg (CMSG_COMMENT, NTXT ("Notes:"));
1748 notesq->append (m);
1749 }
1750
1751 while (1)
1752 {
1753 char str[MAXPATHLEN];
1754 char *e = fgets (str, ((int) sizeof (str)) - 1, f);
1755 if (e == NULL)
1756 {
1757 if (!dbeSession->is_interactive ())
1758 {
1759 m = new Emsg (CMSG_COMMENT,
1760 "============================================================");
1761 notesq->append (m);
1762 }
1763 break;
1764 }
1765 size_t i = strlen (str);
1766 if (i > 0 && str[i - 1] == '\n')
1767 // remove trailing nl
1768 str[i - 1] = 0;
1769 m = new Emsg (CMSG_COMMENT, str);
1770 notesq->append (m);
1771 }
1772 (void) fclose (f);
1773 }
1774
1775 int
1776 Experiment::save_notes (char* text, bool handle_file)
1777 {
1778 if (handle_file)
1779 {
1780 FILE *fnotes;
1781 char *fname = dbe_sprintf (NTXT ("%s/%s"), expt_name, SP_NOTES_FILE);
1782 fnotes = fopen (fname, NTXT ("w"));
1783 free (fname);
1784 if (fnotes != NULL)
1785 {
1786 (void) fprintf (fnotes, NTXT ("%s"), text);
1787 fclose (fnotes);
1788 }
1789 else
1790 return 1; // Cannot write file
1791 }
1792 notesq->clear ();
1793 Emsg *m = new Emsg (CMSG_COMMENT, text);
1794 notesq->append (m);
1795
1796 return 0;
1797 }
1798
1799 int
1800 Experiment::delete_notes (bool handle_file)
1801 {
1802 if (handle_file)
1803 {
1804 char *fname = dbe_sprintf (NTXT ("%s/%s"), expt_name, SP_NOTES_FILE);
1805 if (unlink (fname) != 0)
1806 {
1807 free (fname);
1808 return 1; // Cannot delete file
1809 }
1810 free (fname);
1811 }
1812 notesq->clear ();
1813 return 0;
1814 }
1815
1816 int
1817 Experiment::read_warn_file ()
1818 {
1819 int local_status = SUCCESS;
1820
1821 ExperimentFile *warnFile = new ExperimentFile (this, SP_WARN_FILE);
1822 if (warnFile == NULL)
1823 return FAILURE;
1824 if (!warnFile->open ())
1825 {
1826 delete warnFile;
1827 return FAILURE;
1828 }
1829 SAXParserFactory *factory = SAXParserFactory::newInstance ();
1830 SAXParser *saxParser = factory->newSAXParser ();
1831 DefaultHandler *dh = new ExperimentHandler (this);
1832 try
1833 {
1834 saxParser->parse ((File*) warnFile->fh, dh);
1835 }
1836 catch (SAXException *e)
1837 {
1838 // Fatal error in the parser
1839 StringBuilder sb;
1840 sb.sprintf (NTXT ("%s: %s"), SP_WARN_FILE, e->getMessage ());
1841 char *str = sb.toString ();
1842 Emsg *m = new Emsg (CMSG_FATAL, str);
1843 errorq->append (m);
1844 local_status = FAILURE;
1845 delete e;
1846 }
1847 delete warnFile;
1848 delete dh;
1849 delete saxParser;
1850 delete factory;
1851
1852 return local_status;
1853 }
1854
1855 int
1856 Experiment::read_log_file ()
1857 {
1858 if (logFile == NULL)
1859 logFile = new ExperimentFile (this, SP_LOG_FILE);
1860 if (!logFile->open ())
1861 {
1862 status = FAILURE;
1863 return status;
1864 }
1865
1866 SAXParserFactory *factory = SAXParserFactory::newInstance ();
1867 SAXParser *saxParser = factory->newSAXParser ();
1868 DefaultHandler *dh = new ExperimentHandler (this);
1869 try
1870 {
1871 saxParser->parse ((File*) logFile->fh, dh);
1872 }
1873 catch (SAXException *e)
1874 {
1875 // Fatal error in the parser
1876 StringBuilder sb;
1877 if (obsolete == 1)
1878 sb.sprintf (NTXT ("%s"), e->getMessage ());
1879 else
1880 sb.sprintf (NTXT ("%s: %s"), SP_LOG_FILE, e->getMessage ());
1881 char *str = sb.toString ();
1882 Emsg *m = new Emsg (CMSG_FATAL, str);
1883 errorq->append (m);
1884 status = FAILURE;
1885 delete e;
1886 }
1887 logFile->close ();
1888 dbeSession->register_metric (GTXT ("IPC"), GTXT ("Instructions Per Cycle"),
1889 NTXT ("insts/cycles"));
1890 dbeSession->register_metric (GTXT ("CPI"), GTXT ("Cycles Per Instruction"),
1891 NTXT ("cycles/insts"));
1892 dbeSession->register_metric (GTXT ("K_IPC"),
1893 GTXT ("Kernel Instructions Per Cycle"),
1894 NTXT ("K_insts/K_cycles"));
1895 dbeSession->register_metric (GTXT ("K_CPI"),
1896 GTXT ("Kernel Cycles Per Instruction"),
1897 NTXT ("K_cycles/K_insts"));
1898
1899 delete dh;
1900 delete saxParser;
1901 delete factory;
1902
1903 return status;
1904 }
1905
1906 ////////////////////////////////////////////////////////////////////////////////
1907 // class Experiment::ExperimentLabelsHandler
1908 //
1909
1910 class Experiment::ExperimentLabelsHandler : public DefaultHandler
1911 {
1912 public:
1913
1914 ExperimentLabelsHandler (Experiment *_exp)
1915 {
1916 exp = _exp;
1917 }
1918
1919 ~ExperimentLabelsHandler () { };
1920 void startDocument () { }
1921 void endDocument () { }
1922 void endElement (char * /*uri*/, char * /*localName*/, char * /*qName*/) { }
1923 void characters (char * /*ch*/, int /*start*/, int /*length*/) { }
1924 void ignorableWhitespace (char*, int, int) { }
1925 void error (SAXParseException * /*e*/) { }
1926
1927 void startElement (char *uri, char *localName, char *qName, Attributes *attrs);
1928
1929 private:
1930
1931 inline const char *
1932 s2s (const char *s)
1933 {
1934 return s ? s : "NULL";
1935 }
1936
1937 Experiment *exp;
1938 char *hostname;
1939 hrtime_t time, tstamp;
1940 };
1941
1942 void
1943 Experiment::ExperimentLabelsHandler::startElement (char*, char*, char *qName,
1944 Attributes *attrs)
1945 {
1946 DEBUG_CODE if (DEBUG_SAXPARSER) dump_startElement (qName, attrs);
1947 if (qName == NULL || strcmp (qName, NTXT ("id")) != 0)
1948 return;
1949 char *name = NULL, *all_times = NULL, *comment = NULL, *hostName = NULL;
1950 long startSec = 0;
1951 // long tm_zone = 0;
1952 hrtime_t startHrtime = (hrtime_t) 0;
1953 long long lbl_ts = 0;
1954 int relative = 0;
1955 timeval start_tv;
1956 start_tv.tv_usec = start_tv.tv_sec = 0;
1957 for (int i = 0, sz = attrs ? attrs->getLength () : 0; i < sz; i++)
1958 {
1959 const char *qn = attrs->getQName (i);
1960 const char *vl = attrs->getValue (i);
1961 if (strcmp (qn, NTXT ("name")) == 0)
1962 name = dbe_xml2str (vl);
1963 else if (strcmp (qn, NTXT ("cmd")) == 0)
1964 all_times = dbe_xml2str (vl);
1965 else if (strcmp (qn, NTXT ("comment")) == 0)
1966 comment = dbe_xml2str (vl);
1967 else if (strcmp (qn, NTXT ("relative")) == 0)
1968 relative = atoi (vl);
1969 else if (strcmp (qn, NTXT ("hostname")) == 0)
1970 hostName = dbe_xml2str (vl);
1971 else if (strcmp (qn, NTXT ("time")) == 0)
1972 startSec = atol (vl);
1973 else if (strcmp (qn, NTXT ("tstamp")) == 0)
1974 startHrtime = parseTStamp (vl);
1975 else if (strcmp (qn, NTXT ("lbl_ts")) == 0)
1976 {
1977 if (*vl == '-')
1978 lbl_ts = -parseTStamp (vl + 1);
1979 else
1980 lbl_ts = parseTStamp (vl);
1981 }
1982 }
1983 if (name == NULL || hostName == NULL || (all_times == NULL && comment == NULL))
1984 {
1985 free (name);
1986 free (hostName);
1987 free (all_times);
1988 free (comment);
1989 return;
1990 }
1991 UserLabel *lbl = new UserLabel (name);
1992 lbl->comment = comment;
1993 lbl->hostname = hostName;
1994 lbl->start_sec = startSec;
1995 lbl->start_hrtime = startHrtime;
1996 exp->userLabels->append (lbl);
1997 if (all_times)
1998 {
1999 lbl->all_times = all_times;
2000 lbl->start_tv = start_tv;
2001 lbl->relative = relative;
2002 if (relative == UserLabel::REL_TIME)
2003 lbl->atime = lbl_ts;
2004 else
2005 { // relative == UserLabel::CUR_TIME
2006 long long delta = 0;
2007 if (exp->hostname && strcmp (lbl->hostname, exp->hostname) == 0)
2008 delta = lbl_ts + (lbl->start_hrtime - exp->exp_start_time);
2009 else
2010 for (int i = 0; i < exp->userLabels->size (); i++)
2011 {
2012 UserLabel *firstLbl = exp->userLabels->fetch (i);
2013 if (strcmp (lbl->hostname, firstLbl->hostname) == 0)
2014 {
2015 delta = lbl_ts + (lbl->start_hrtime - firstLbl->start_hrtime) +
2016 ((long long) (firstLbl->start_sec - exp->start_sec)) * NANOSEC;
2017 break;
2018 }
2019 }
2020 lbl->atime = delta > 0 ? delta : 0;
2021 }
2022 }
2023 }
2024
2025 static int
2026 sortUserLabels (const void *a, const void *b)
2027 {
2028 UserLabel *l1 = *((UserLabel **) a);
2029 UserLabel *l2 = *((UserLabel **) b);
2030 int v = dbe_strcmp (l1->name, l2->name);
2031 if (v != 0)
2032 return v;
2033 if (l1->atime < l2->atime)
2034 return -1;
2035 else if (l1->atime > l2->atime)
2036 return 1;
2037 if (l1->id < l2->id)
2038 return -1;
2039 else if (l1->id > l2->id)
2040 return 1;
2041 return 0;
2042 }
2043
2044 static char *
2045 append_string (char *s, char *str)
2046 {
2047 if (s == NULL)
2048 return dbe_strdup (str);
2049 char *new_s = dbe_sprintf (NTXT ("%s %s"), s, str);
2050 free (s);
2051 return new_s;
2052 }
2053
2054 void
2055 Experiment::read_labels_file ()
2056 {
2057 ExperimentFile *fp = new ExperimentFile (this, SP_LABELS_FILE);
2058 if (!fp->open ())
2059 {
2060 delete fp;
2061 return;
2062 }
2063 userLabels = new Vector<UserLabel*>();
2064 SAXParserFactory *factory = SAXParserFactory::newInstance ();
2065 SAXParser *saxParser = factory->newSAXParser ();
2066 DefaultHandler *dh = new ExperimentLabelsHandler (this);
2067 try
2068 {
2069 saxParser->parse ((File*) fp->fh, dh);
2070 }
2071 catch (SAXException *e)
2072 {
2073 // Fatal error in the parser
2074 StringBuilder sb;
2075 sb.sprintf (NTXT ("%s: %s"), SP_LABELS_FILE, e->getMessage ());
2076 char *str = sb.toString ();
2077 Emsg *m = new Emsg (CMSG_FATAL, str);
2078 errorq->append (m);
2079 delete e;
2080 }
2081 fp->close ();
2082 delete fp;
2083 delete dh;
2084 delete saxParser;
2085 delete factory;
2086
2087 userLabels->sort (sortUserLabels);
2088 UserLabel::dump ("After sortUserLabels:", userLabels);
2089 UserLabel *ulbl = NULL;
2090 for (int i = 0, sz = userLabels->size (); i < sz; i++)
2091 {
2092 UserLabel *lbl = userLabels->fetch (i);
2093 if (ulbl == NULL)
2094 ulbl = new UserLabel (lbl->name);
2095 else if (dbe_strcmp (lbl->name, ulbl->name) != 0)
2096 { // new Label
2097 ulbl->register_user_label (groupId);
2098 if (ulbl->expr == NULL)
2099 delete ulbl;
2100 ulbl = new UserLabel (lbl->name);
2101 }
2102 if (lbl->all_times)
2103 {
2104 if (strncmp (lbl->all_times, NTXT ("start"), 5) == 0)
2105 {
2106 if (!ulbl->start_f)
2107 {
2108 ulbl->start_f = true;
2109 ulbl->timeStart = lbl->atime;
2110 }
2111 }
2112 else
2113 { // stop
2114 if (!ulbl->start_f)
2115 continue;
2116 ulbl->all_times = append_string (ulbl->all_times, lbl->all_times);
2117 ulbl->stop_f = true;
2118 ulbl->timeStop = lbl->atime;
2119 ulbl->gen_expr ();
2120 }
2121 }
2122 if (lbl->comment != NULL)
2123 ulbl->comment = append_string (ulbl->comment, lbl->comment);
2124 }
2125 if (ulbl)
2126 {
2127 ulbl->register_user_label (groupId);
2128 if (ulbl->expr == NULL)
2129 delete ulbl;
2130 }
2131 Destroy (userLabels);
2132 }
2133
2134 void
2135 Experiment::read_archives ()
2136 {
2137 if (founder_exp)
2138 return;
2139 char *allocated_str = NULL;
2140 char *nm = get_arch_name ();
2141 DIR *exp_dir = opendir (nm);
2142 if (exp_dir == NULL)
2143 {
2144 if (founder_exp == NULL)
2145 {
2146 // Check if the user uses a subexperiment only
2147 nm = dbe_sprintf (NTXT ("%s/../%s"), expt_name, SP_ARCHIVES_DIR);
2148 exp_dir = opendir (nm);
2149 if (exp_dir == NULL)
2150 {
2151 free (nm);
2152 return;
2153 }
2154 allocated_str = nm;
2155 }
2156 else
2157 return;
2158 }
2159
2160 StringBuilder sb;
2161 sb.append (nm);
2162 sb.append ('/');
2163 int dlen = sb.length ();
2164 free (allocated_str);
2165 archiveMap = new StringMap<DbeFile *>();
2166
2167 struct dirent *entry = NULL;
2168 while ((entry = readdir (exp_dir)) != NULL)
2169 {
2170 char *dname = entry->d_name;
2171 if (dname[0] == '.'
2172 && (dname[1] == '\0' || (dname[1] == '.' && dname[2] == '\0')))
2173 // skip links to ./ or ../
2174 continue;
2175 sb.setLength (dlen);
2176 sb.append (dname);
2177 char *fnm = sb.toString ();
2178 DbeFile *df = new DbeFile (fnm);
2179 df->set_location (fnm);
2180 df->filetype |= DbeFile::F_FILE;
2181 df->inArchive = true;
2182 df->experiment = this;
2183 archiveMap->put (dname, df);
2184 free (fnm);
2185 }
2186 closedir (exp_dir);
2187 }
2188
2189 static char *
2190 gen_file_name (const char *packet_name, const char *src_name)
2191 {
2192 char *fnm, *bname = get_basename (packet_name);
2193 if (bname == packet_name)
2194 fnm = dbe_strdup (src_name);
2195 else
2196 fnm = dbe_sprintf ("%.*s%s", (int) (bname - packet_name),
2197 packet_name, src_name);
2198
2199 // convert "java.lang.Object/Integer.java" => "java/lang/Object/Integer.java"
2200 bname = get_basename (fnm);
2201 for (char *s = fnm; s < bname; s++)
2202 if (*s == '.')
2203 *s = '/';
2204 return fnm;
2205 }
2206
2207 static char *
2208 get_jlass_name (const char *nm)
2209 {
2210 // Convert "Ljava/lang/Object;" => "java/lang/Object.class"
2211 if (*nm == 'L')
2212 {
2213 size_t len = strlen (nm);
2214 if (nm[len - 1] == ';')
2215 return dbe_sprintf ("%.*s.class", (int) (len - 2), nm + 1);
2216 }
2217 return dbe_strdup (nm);
2218 }
2219
2220 static char *
2221 get_jmodule_name (const char *nm)
2222 {
2223 // convert "Ljava/lang/Object;" => "java.lang.Object"
2224 if (*nm == 'L')
2225 {
2226 size_t len = strlen (nm);
2227 if (nm[len - 1] == ';')
2228 {
2229 char *mname = dbe_sprintf (NTXT ("%.*s"), (int) (len - 2), nm + 1);
2230 for (char *s = mname; *s; s++)
2231 if (*s == '/')
2232 *s = '.';
2233 return mname;
2234 }
2235 }
2236 return dbe_strdup (nm);
2237 }
2238
2239 LoadObject *
2240 Experiment::get_j_lo (const char *className, const char *fileName)
2241 {
2242 char *class_name = get_jlass_name (className);
2243 Dprintf (DUMP_JCLASS_READER,
2244 "Experiment::get_j_lo: className='%s' class_name='%s' fileName='%s'\n",
2245 STR (className), STR (class_name), STR (fileName));
2246 LoadObject *lo = loadObjMap->get (class_name);
2247 if (lo == NULL)
2248 {
2249 lo = createLoadObject (class_name, fileName);
2250 lo->type = LoadObject::SEG_TEXT;
2251 lo->mtime = (time_t) 0;
2252 lo->size = 0;
2253 lo->set_platform (Java, wsize);
2254 lo->dbeFile->filetype |= DbeFile::F_FILE | DbeFile::F_JAVACLASS;
2255 append (lo);
2256 Dprintf (DUMP_JCLASS_READER,
2257 "Experiment::get_j_lo: creates '%s' location='%s'\n",
2258 STR (lo->get_name ()), STR (lo->dbeFile->get_location (false)));
2259 }
2260 free (class_name);
2261 return lo;
2262 }
2263
2264 Module *
2265 Experiment::get_jclass (const char *className, const char *fileName)
2266 {
2267 LoadObject *lo = get_j_lo (className, NULL);
2268 char *mod_name = get_jmodule_name (className);
2269 Module *mod = lo->find_module (mod_name);
2270 if (mod == NULL)
2271 {
2272 mod = dbeSession->createClassFile (mod_name);
2273 mod->loadobject = lo;
2274 if (strcmp (fileName, NTXT ("<Unknown>")) != 0)
2275 mod->set_file_name (gen_file_name (lo->get_pathname (), fileName));
2276 else
2277 mod->set_file_name (dbe_strdup (fileName));
2278 lo->append_module (mod);
2279 mod_name = NULL;
2280 }
2281 else if (mod->file_name && (strcmp (mod->file_name, "<Unknown>") == 0)
2282 && strcmp (fileName, "<Unknown>") != 0)
2283 mod->set_file_name (gen_file_name (lo->get_pathname (), fileName));
2284 Dprintf (DUMP_JCLASS_READER,
2285 "Experiment::get_jclass: class_name='%s' mod_name='%s' fileName='%s'\n",
2286 mod->loadobject->get_pathname (), mod->get_name (), mod->file_name);
2287 free (mod_name);
2288 return mod;
2289 }
2290
2291 #define ARCH_STRLEN(s) ( ( strlen(s) + 4 ) & ~0x3 )
2292
2293 int
2294 Experiment::read_java_classes_file ()
2295 {
2296 char *data_file_name = dbe_sprintf (NTXT ("%s/%s"), expt_name, SP_JCLASSES_FILE);
2297 Data_window *dwin = new Data_window (data_file_name);
2298 free (data_file_name);
2299 if (dwin->not_opened ())
2300 {
2301 delete dwin;
2302 return INCOMPLETE;
2303 }
2304 dwin->need_swap_endian = need_swap_endian;
2305 jmaps = new PRBTree ();
2306 jmidHTable = new DbeCacheMap<unsigned long long, JMethod>;
2307
2308 hrtime_t cur_loaded = 0;
2309 Module *cur_mod = NULL;
2310 for (int64_t offset = 0;;)
2311 {
2312 CM_Packet *cpkt = (CM_Packet*) dwin->bind (offset, sizeof (CM_Packet));
2313 if (cpkt == NULL)
2314 break;
2315 uint16_t v16 = (uint16_t) cpkt->tsize;
2316 size_t cpktsize = dwin->decode (v16);
2317 cpkt = (CM_Packet*) dwin->bind (offset, cpktsize);
2318 if ((cpkt == NULL) || (cpktsize == 0))
2319 {
2320 char *buf = dbe_sprintf (GTXT ("archive file malformed %s"),
2321 arch_name);
2322 errorq->append (new Emsg (CMSG_ERROR, buf));
2323 free (buf);
2324 break;
2325 }
2326 v16 = (uint16_t) cpkt->type;
2327 v16 = dwin->decode (v16);
2328 switch (v16)
2329 {
2330 case ARCH_JCLASS:
2331 {
2332 ARCH_jclass *ajcl = (ARCH_jclass*) cpkt;
2333 uint64_t class_id = dwin->decode (ajcl->class_id);
2334 char *className = ((char*) ajcl) + sizeof (*ajcl);
2335 char *fileName = className + ARCH_STRLEN (className);
2336 Dprintf (DUMP_JCLASS_READER,
2337 "read_java_classes_file: ARCH_JCLASS(Ox%x)"
2338 "class_id=Ox%llx className='%s' fileName='%s' \n",
2339 (int) v16, (long long) class_id, className, fileName);
2340 cur_mod = NULL;
2341 if (*className == 'L')
2342 { // Old libcollector generated '[' (one array dimension).
2343 cur_mod = get_jclass (className, fileName);
2344 cur_loaded = dwin->decode (ajcl->tstamp);
2345 jmaps->insert (class_id, cur_loaded, cur_mod);
2346 }
2347 break;
2348 }
2349 case ARCH_JCLASS_LOCATION:
2350 {
2351 ARCH_jclass_location *ajcl = (ARCH_jclass_location *) cpkt;
2352 uint64_t class_id = dwin->decode (ajcl->class_id);
2353 char *className = ((char*) ajcl) + sizeof (*ajcl);
2354 char *fileName = className + ARCH_STRLEN (className);
2355 Dprintf (DUMP_JCLASS_READER,
2356 "read_java_classes_file: ARCH_JCLASS_LOCATION(Ox%x)"
2357 "class_id=Ox%llx className='%s' fileName='%s' \n",
2358 (int) v16, (long long) class_id, className, fileName);
2359 get_j_lo (className, fileName);
2360 break;
2361 }
2362 case ARCH_JMETHOD:
2363 {
2364 if (cur_mod == NULL)
2365 break;
2366 ARCH_jmethod *ajmt = (ARCH_jmethod*) cpkt;
2367 uint64_t method_id = dwin->decode (ajmt->method_id);
2368 char *s_name = ((char*) ajmt) + sizeof (*ajmt);
2369 char *s_signature = s_name + ARCH_STRLEN (s_name);
2370 char *fullname = dbe_sprintf ("%s.%s", cur_mod->get_name (), s_name);
2371 Dprintf (DUMP_JCLASS_READER,
2372 "read_java_classes_file: ARCH_JMETHOD(Ox%x) "
2373 "method_id=Ox%llx name='%s' signature='%s' fullname='%s'\n",
2374 (int) v16, (long long) method_id, s_name,
2375 s_signature, fullname);
2376 JMethod *jmthd = cur_mod->find_jmethod (fullname, s_signature);
2377 if (jmthd == NULL)
2378 {
2379 jmthd = dbeSession->createJMethod ();
2380 jmthd->size = (unsigned) - 1; // unknown until later (maybe)
2381 jmthd->module = cur_mod;
2382 jmthd->set_signature (s_signature);
2383 jmthd->set_name (fullname);
2384 cur_mod->functions->append (jmthd);
2385 cur_mod->loadobject->functions->append (jmthd);
2386 Dprintf (DUMP_JCLASS_READER,
2387 "read_java_classes_file: ARCH_JMETHOD CREATE fullname=%s\n",
2388 fullname);
2389 }
2390 jmaps->insert (method_id, cur_loaded, jmthd);
2391 free (fullname);
2392 break;
2393 }
2394 default:
2395 Dprintf (DUMP_JCLASS_READER,
2396 "read_java_classes_file: type=Ox%x (%d) cpktsize=%d\n",
2397 (int) v16, (int) v16, (int) cpktsize);
2398 break; // ignore unknown packets
2399 }
2400 offset += cpktsize;
2401 }
2402 delete dwin;
2403 return SUCCESS;
2404 }
2405
2406 void
2407 Experiment::read_map_file ()
2408 {
2409 ExperimentFile *mapFile = new ExperimentFile (this, SP_MAP_FILE);
2410 if (!mapFile->open ())
2411 {
2412 delete mapFile;
2413 return;
2414 }
2415
2416 SAXParserFactory *factory = SAXParserFactory::newInstance ();
2417 SAXParser *saxParser = factory->newSAXParser ();
2418 DefaultHandler *dh = new ExperimentHandler (this);
2419 try
2420 {
2421 saxParser->parse ((File*) mapFile->fh, dh);
2422 }
2423 catch (SAXException *e)
2424 {
2425 // Fatal error in the parser
2426 StringBuilder sb;
2427 sb.sprintf (NTXT ("%s: %s"), SP_MAP_FILE, e->getMessage ());
2428 char *str = sb.toString ();
2429 Emsg *m = new Emsg (CMSG_FATAL, str);
2430 errorq->append (m);
2431 status = FAILURE;
2432 free (str);
2433 delete e;
2434 }
2435 delete mapFile;
2436 delete dh;
2437 delete saxParser;
2438 delete factory;
2439
2440 for (int i = 0, sz = mrecs ? mrecs->size () : 0; i < sz; i++)
2441 {
2442 MapRecord *mrec = mrecs->fetch (i);
2443 SegMem *smem, *sm_lo, *sm_hi;
2444 switch (mrec->kind)
2445 {
2446 case MapRecord::LOAD:
2447 smem = new SegMem;
2448 smem->base = mrec->base;
2449 smem->size = mrec->size;
2450 smem->load_time = mrec->ts;
2451 smem->unload_time = MAX_TIME;
2452 smem->obj = mrec->obj;
2453 smem->set_file_offset (mrec->foff);
2454 seg_items->append (smem); // add to the master list
2455
2456 // Check if the new segment overlaps other active segments
2457 sm_lo = (SegMem*) maps->locate (smem->base, smem->load_time);
2458 if (sm_lo && sm_lo->base + sm_lo->size > smem->base)
2459 {
2460 // check to see if it is a duplicate record: same address and size, and
2461 if ((smem->base == sm_lo->base) && (smem->size == sm_lo->size))
2462 {
2463 // addresses and sizes match, check name
2464 if (strstr (smem->obj->get_name (), sm_lo->obj->get_name ()) != NULL
2465 || strstr (sm_lo->obj->get_name (), smem->obj->get_name ()) != NULL)
2466 // this is a duplicate; just move on the the next map record
2467 continue;
2468 fprintf (stderr,
2469 GTXT ("*** Warning: Segment `%s' loaded with same address, size as `%s' [0x%llx-0x%llx]\n"),
2470 smem->obj->get_name (), sm_lo->obj->get_name (),
2471 sm_lo->base, sm_lo->base + sm_lo->size);
2472 }
2473
2474 // Not a duplicate; implicitly unload the old one
2475 // Note: implicit unloading causes high <Unknown>
2476 // when such overlapping is bogus
2477 StringBuilder sb;
2478 sb.sprintf (GTXT ("*** Warning: Segment %s [0x%llx-0x%llx] overlaps %s [0x%llx-0x%llx], which has been implicitly unloaded"),
2479 smem->obj->get_name (), smem->base, smem->base + smem->size,
2480 sm_lo->obj->get_name (), sm_lo->base, sm_lo->base + sm_lo->size);
2481 warnq->append (new Emsg (CMSG_WARN, sb));
2482 }
2483
2484 // now look for other segments with which this might overlap
2485 sm_hi = (SegMem*) maps->locate_up (smem->base, smem->load_time);
2486 while (sm_hi && sm_hi->base < smem->base + smem->size)
2487 {
2488
2489 // Note: implicit unloading causes high <Unknown> when such overlapping is bogus
2490 // maps->remove( sm_hi->base, smem->load_time );
2491 StringBuilder sb;
2492 sb.sprintf (GTXT ("*** Warning: Segment %s [0x%llx-0x%llx] overlaps %s [0x%llx-0x%llx], which has been implicitly unloaded"),
2493 smem->obj->get_name (), smem->base,
2494 smem->base + smem->size, sm_hi->obj->get_name (),
2495 sm_hi->base, sm_hi->base + sm_hi->size);
2496 warnq->append (new Emsg (CMSG_WARN, sb));
2497 sm_hi = (SegMem*) maps->locate_up (sm_hi->base + sm_hi->size,
2498 smem->load_time);
2499 }
2500
2501 maps->insert (smem->base, smem->load_time, smem);
2502 break;
2503 case MapRecord::UNLOAD:
2504 smem = (SegMem*) maps->locate (mrec->base, mrec->ts);
2505 if (smem && smem->base == mrec->base)
2506 {
2507 smem->unload_time = mrec->ts;
2508 maps->remove (mrec->base, mrec->ts);
2509 }
2510 break;
2511 }
2512 }
2513 mrecs->destroy ();
2514
2515 // See if there are comments or warnings for a load object;
2516 // if so, queue them to Experiment
2517 for (long i = 0, sz = loadObjs ? loadObjs->size () : 0; i < sz; i++)
2518 {
2519 LoadObject *lo = loadObjs->get (i);
2520 for (Emsg *m = lo->fetch_warnings (); m; m = m->next)
2521 warnq->append (m->get_warn (), m->get_msg ());
2522 for (Emsg *m = lo->fetch_comments (); m; m = m->next)
2523 commentq->append (m->get_warn (), m->get_msg ());
2524 }
2525 }
2526
2527 void
2528 Experiment::read_frameinfo_file ()
2529 {
2530 init_cache ();
2531 char *base_name = get_basename (expt_name);
2532 char *msg = dbe_sprintf (GTXT ("Loading CallStack Data: %s"), base_name);
2533 read_data_file ("data." SP_FRINFO_FILE, msg);
2534 free (msg);
2535 frmpckts->sort (frUidCmp);
2536 uidnodes->sort (uidNodeCmp);
2537 }
2538
2539 void
2540 Experiment::read_omp_preg ()
2541 {
2542 // Parallel region descriptions
2543 DataDescriptor *pregDdscr = getDataDescriptor (DATA_OMP4);
2544 if (pregDdscr == NULL)
2545 return;
2546 DataView *pregData = pregDdscr->createView ();
2547 pregData->sort (PROP_CPRID); // omptrace PROP_CPRID
2548
2549 // OpenMP enter parreg events
2550 DataDescriptor *dDscr = getDataDescriptor (DATA_OMP2);
2551 if (dDscr == NULL || dDscr->getSize () == 0)
2552 {
2553 delete pregData;
2554 return;
2555 }
2556
2557 char *idxname = NTXT ("OMP_preg");
2558 delete dbeSession->indxobj_define (idxname, GTXT ("OpenMP Parallel Region"),
2559 NTXT ("CPRID"), NULL, NULL);
2560 int idxtype = dbeSession->findIndexSpaceByName (idxname);
2561 if (idxtype < 0)
2562 {
2563 delete pregData;
2564 return;
2565 }
2566 ompavail = true;
2567
2568 // Pre-create parallel region with id == 0
2569 Histable *preg0 = dbeSession->createIndexObject (idxtype, (int64_t) 0);
2570 preg0->set_name (dbe_strdup (GTXT ("Implicit OpenMP Parallel Region")));
2571
2572 // Take care of the progress bar
2573 char *msg = dbe_sprintf (GTXT ("Processing OpenMP Parallel Region Data: %s"),
2574 get_basename (expt_name));
2575 theApplication->set_progress (0, msg);
2576 free (msg);
2577 long deltaReport = 1000;
2578 long nextReport = 0;
2579 long errors_found = 0;
2580 Vector<Histable*> pregs;
2581
2582 long size = dDscr->getSize ();
2583 for (long i = 0; i < size; ++i)
2584 {
2585 if (i == nextReport)
2586 {
2587 int percent = (int) (i * 100 / size);
2588 if (percent > 0)
2589 theApplication->set_progress (percent, NULL);
2590 nextReport += deltaReport;
2591 }
2592
2593 uint32_t thrid = dDscr->getIntValue (PROP_THRID, i);
2594 hrtime_t tstamp = dDscr->getLongValue (PROP_TSTAMP, i);
2595 uint64_t cprid = dDscr->getLongValue (PROP_CPRID, i); // omptrace CPRID
2596 mapPRid->put (thrid, tstamp, cprid);
2597
2598 pregs.reset ();
2599 /*
2600 * We will use 2 pointers to make sure there is no loop.
2601 * First pointer "curpreg" goes to the next element,
2602 * second pointer "curpreg_loop_control" goes to the next->next element.
2603 * If these pointers have the same value - there is a loop.
2604 */
2605 uint64_t curpreg_loop_control = cprid;
2606 Datum tval_loop_control;
2607 if (curpreg_loop_control != 0)
2608 {
2609 tval_loop_control.setUINT64 (curpreg_loop_control);
2610 long idx = pregData->getIdxByVals (&tval_loop_control, DataView::REL_EQ);
2611 if (idx < 0)
2612 curpreg_loop_control = 0;
2613 else
2614 curpreg_loop_control = pregData->getLongValue (PROP_PPRID, idx);
2615 }
2616 for (uint64_t curpreg = cprid; curpreg != 0;)
2617 {
2618 Histable *val = NULL;
2619 Datum tval;
2620 tval.setUINT64 (curpreg);
2621 long idx = pregData->getIdxByVals (&tval, DataView::REL_EQ);
2622 if (idx < 0)
2623 break;
2624 /*
2625 * Check if there is a loop
2626 */
2627 if (0 != curpreg_loop_control)
2628 {
2629 if (curpreg == curpreg_loop_control)
2630 {
2631 errors_found++;
2632 if (1 == errors_found)
2633 {
2634 Emsg *m = new Emsg (CMSG_WARN, GTXT ("*** Warning: circular links in OMP regions; data may not be correct."));
2635 warnq->append (m);
2636 }
2637 break;
2638 }
2639 }
2640 uint64_t pragmapc = pregData->getLongValue (PROP_PRPC, idx);
2641 DbeInstr *instr = map_Vaddr_to_PC (pragmapc, tstamp);
2642 if (instr == NULL)
2643 {
2644 break;
2645 }
2646 val = instr;
2647 DbeLine *dbeline = (DbeLine*) instr->convertto (Histable::LINE);
2648 if (dbeline->lineno > 0)
2649 {
2650 if (instr->func->usrfunc)
2651 dbeline = dbeline->sourceFile->find_dbeline
2652 (instr->func->usrfunc, dbeline->lineno);
2653 dbeline->set_flag (DbeLine::OMPPRAGMA);
2654 val = dbeline;
2655 }
2656 val = dbeSession->createIndexObject (idxtype, val);
2657 pregs.append (val);
2658
2659 curpreg = pregData->getLongValue (PROP_PPRID, idx);
2660 /*
2661 * Update curpreg_loop_control
2662 */
2663 if (0 != curpreg_loop_control)
2664 {
2665 tval_loop_control.setUINT64 (curpreg_loop_control);
2666 idx = pregData->getIdxByVals
2667 (&tval_loop_control, DataView::REL_EQ);
2668 if (idx < 0)
2669 curpreg_loop_control = 0;
2670 else
2671 {
2672 curpreg_loop_control = pregData->getLongValue
2673 (PROP_PPRID, idx);
2674 tval_loop_control.setUINT64 (curpreg_loop_control);
2675 idx = pregData->getIdxByVals
2676 (&tval_loop_control, DataView::REL_EQ);
2677 if (idx < 0)
2678 curpreg_loop_control = 0;
2679 else
2680 curpreg_loop_control = pregData->getLongValue
2681 (PROP_PPRID, idx);
2682 }
2683 }
2684 }
2685 pregs.append (preg0);
2686 void *prstack = cstack->add_stack (&pregs);
2687 mapPReg->put (thrid, tstamp, prstack);
2688 }
2689 theApplication->set_progress (0, NTXT (""));
2690 delete pregData;
2691 }
2692
2693 void
2694 Experiment::read_omp_task ()
2695 {
2696 // Task description
2697 DataDescriptor *taskDataDdscr = getDataDescriptor (DATA_OMP5);
2698 if (taskDataDdscr == NULL)
2699 return;
2700
2701 //7035272: previously, DataView was global; now it's local...is this OK?
2702 DataView *taskData = taskDataDdscr->createView ();
2703 taskData->sort (PROP_TSKID); // omptrace PROP_TSKID
2704
2705 // OpenMP enter task events
2706 DataDescriptor *dDscr = getDataDescriptor (DATA_OMP3);
2707 if (dDscr == NULL || dDscr->getSize () == 0)
2708 {
2709 delete taskData;
2710 return;
2711 }
2712
2713 char *idxname = NTXT ("OMP_task");
2714 // delete a possible error message. Ugly.
2715 delete dbeSession->indxobj_define (idxname, GTXT ("OpenMP Task"), NTXT ("TSKID"), NULL, NULL);
2716 int idxtype = dbeSession->findIndexSpaceByName (idxname);
2717 if (idxtype < 0)
2718 {
2719 delete taskData;
2720 return;
2721 }
2722 ompavail = true;
2723
2724 // Pre-create task with id == 0
2725 Histable *task0 = dbeSession->createIndexObject (idxtype, (int64_t) 0);
2726 task0->set_name (dbe_strdup (GTXT ("OpenMP Task from Implicit Parallel Region")));
2727
2728 // Take care of the progress bar
2729 char *msg = dbe_sprintf (GTXT ("Processing OpenMP Task Data: %s"), get_basename (expt_name));
2730 theApplication->set_progress (0, msg);
2731 free (msg);
2732 long deltaReport = 1000;
2733 long nextReport = 0;
2734
2735 Vector<Histable*> tasks;
2736 long size = dDscr->getSize ();
2737 long errors_found = 0;
2738 for (long i = 0; i < size; ++i)
2739 {
2740 if (i == nextReport)
2741 {
2742 int percent = (int) (i * 100 / size);
2743 if (percent > 0)
2744 theApplication->set_progress (percent, NULL);
2745 nextReport += deltaReport;
2746 }
2747
2748 uint32_t thrid = dDscr->getIntValue (PROP_THRID, i);
2749 hrtime_t tstamp = dDscr->getLongValue (PROP_TSTAMP, i);
2750 uint64_t tskid = dDscr->getLongValue (PROP_TSKID, i); //omptrace TSKID
2751 tasks.reset ();
2752 /*
2753 * We will use 2 pointers to make sure there is no loop.
2754 * First pointer "curtsk" goes to the next element,
2755 * second pointer "curtsk_loop_control" goes to the next->next element.
2756 * If these pointers have the same value - there is a loop.
2757 */
2758 uint64_t curtsk_loop_control = tskid;
2759 Datum tval_loop_control;
2760 if (curtsk_loop_control != 0)
2761 {
2762 tval_loop_control.setUINT64 (curtsk_loop_control);
2763 long idx = taskData->getIdxByVals (&tval_loop_control, DataView::REL_EQ);
2764 if (idx < 0)
2765 curtsk_loop_control = 0;
2766 else
2767 curtsk_loop_control = taskData->getLongValue (PROP_PTSKID, idx);
2768 }
2769 for (uint64_t curtsk = tskid; curtsk != 0;)
2770 {
2771 Histable *val = NULL;
2772
2773 Datum tval;
2774 tval.setUINT64 (curtsk);
2775 long idx = taskData->getIdxByVals (&tval, DataView::REL_EQ);
2776 if (idx < 0)
2777 break;
2778 /*
2779 * Check if there is a loop
2780 */
2781 if (0 != curtsk_loop_control)
2782 {
2783 if (curtsk == curtsk_loop_control)
2784 {
2785 errors_found++;
2786 if (1 == errors_found)
2787 {
2788 Emsg *m = new Emsg (CMSG_WARN, GTXT ("*** Warning: circular links in OMP tasks; data may not be correct."));
2789 warnq->append (m);
2790 }
2791 break;
2792 }
2793 }
2794 uint64_t pragmapc = taskData->getLongValue (PROP_PRPC, idx);
2795 DbeInstr *instr = map_Vaddr_to_PC (pragmapc, tstamp);
2796 if (instr == NULL)
2797 break;
2798 val = instr;
2799 DbeLine *dbeline = (DbeLine*) instr->convertto (Histable::LINE);
2800 if (dbeline->lineno > 0)
2801 {
2802 if (instr->func->usrfunc)
2803 dbeline = dbeline->sourceFile->find_dbeline
2804 (instr->func->usrfunc, dbeline->lineno);
2805 dbeline->set_flag (DbeLine::OMPPRAGMA);
2806 val = dbeline;
2807 }
2808 val = dbeSession->createIndexObject (idxtype, val);
2809 tasks.append (val);
2810
2811 curtsk = taskData->getLongValue (PROP_PTSKID, idx);
2812 /*
2813 * Update curtsk_loop_control
2814 */
2815 if (0 != curtsk_loop_control)
2816 {
2817 tval_loop_control.setUINT64 (curtsk_loop_control);
2818 idx = taskData->getIdxByVals (&tval_loop_control, DataView::REL_EQ);
2819 if (idx < 0)
2820 curtsk_loop_control = 0;
2821 else
2822 {
2823 curtsk_loop_control = taskData->getLongValue (PROP_PTSKID, idx);
2824 tval_loop_control.setUINT64 (curtsk_loop_control);
2825 idx = taskData->getIdxByVals (&tval_loop_control,
2826 DataView::REL_EQ);
2827 if (idx < 0)
2828 curtsk_loop_control = 0;
2829 else
2830 curtsk_loop_control = taskData->getLongValue (PROP_PTSKID,
2831 idx);
2832 }
2833 }
2834 }
2835 tasks.append (task0);
2836 void *tskstack = cstack->add_stack (&tasks);
2837 mapTask->put (thrid, tstamp, tskstack);
2838 }
2839 theApplication->set_progress (0, NTXT (""));
2840 delete taskData;
2841 }
2842
2843 void
2844 Experiment::read_omp_file ()
2845 {
2846 // DATA_OMP2 table is common between OpenMP 2.5 and 3.0 profiling
2847 DataDescriptor *dDscr = getDataDescriptor (DATA_OMP2);
2848 if (dDscr == NULL)
2849 return;
2850 if (dDscr->getSize () == 0)
2851 {
2852 char *base_name = get_basename (expt_name);
2853 char *msg = dbe_sprintf (GTXT ("Loading OpenMP Data: %s"), base_name);
2854 read_data_file (SP_OMPTRACE_FILE, msg);
2855 free (msg);
2856
2857 // OpenMP fork events
2858 dDscr = getDataDescriptor (DATA_OMP);
2859 long sz = dDscr->getSize ();
2860 if (sz > 0)
2861 {
2862 // progress bar
2863 msg = dbe_sprintf (GTXT ("Processing OpenMP Parallel Region Data: %s"),
2864 base_name);
2865 theApplication->set_progress (0, msg);
2866 free (msg);
2867 long deltaReport = 5000;
2868 long nextReport = 0;
2869 for (int i = 0; i < sz; ++i)
2870 {
2871 if (i == nextReport)
2872 {
2873 int percent = (int) (i * 100 / sz);
2874 if (percent > 0)
2875 theApplication->set_progress (percent, NULL);
2876 nextReport += deltaReport;
2877 }
2878 uint32_t thrid = dDscr->getIntValue (PROP_THRID, i);
2879 hrtime_t tstamp = dDscr->getLongValue (PROP_TSTAMP, i);
2880 uint64_t cprid = dDscr->getLongValue (PROP_CPRID, i); //omptrace
2881 mapPRid->put (thrid, tstamp, cprid);
2882 }
2883 theApplication->set_progress (0, NTXT (""));
2884
2885 ompavail = true;
2886 openMPdata = dDscr->createView ();
2887 openMPdata->sort (PROP_CPRID); // omptrace PROP_CPRID
2888
2889 // thread enters parreg events
2890 dDscr = getDataDescriptor (DATA_OMP2);
2891 sz = dDscr->getSize ();
2892
2893 // progress bar
2894 msg = dbe_sprintf (GTXT ("Processing OpenMP Parallel Region Data: %s"),
2895 base_name);
2896 theApplication->set_progress (0, msg);
2897 free (msg);
2898 deltaReport = 5000;
2899 nextReport = 0;
2900
2901 for (int i = 0; i < sz; ++i)
2902 {
2903 if (i == nextReport)
2904 {
2905 int percent = (int) (i * 100 / sz);
2906 if (percent > 0)
2907 theApplication->set_progress (percent, NULL);
2908 nextReport += deltaReport;
2909 }
2910 uint32_t thrid = dDscr->getIntValue (PROP_THRID, i);
2911 hrtime_t tstamp = dDscr->getLongValue (PROP_TSTAMP, i);
2912 uint64_t cprid = dDscr->getLongValue (PROP_CPRID, i); //omptrace
2913 mapPRid->put (thrid, tstamp, cprid);
2914 }
2915 theApplication->set_progress (0, NTXT (""));
2916 }
2917 else
2918 {
2919 read_omp_preg ();
2920 read_omp_task ();
2921 }
2922 if (ompavail && coll_params.profile_mode)
2923 {
2924 dbeSession->status_ompavail = 1;
2925 register_metric (Metric::OMP_WORK);
2926 register_metric (Metric::OMP_WAIT);
2927 register_metric (Metric::OMP_OVHD);
2928 if (coll_params.lms_magic_id == LMS_MAGIC_ID_SOLARIS)
2929 register_metric (Metric::OMP_MASTER_THREAD);
2930 }
2931 }
2932 }
2933
2934 void
2935 Experiment::read_ifreq_file ()
2936 {
2937 char *fname = dbe_sprintf (NTXT ("%s/%s"), expt_name, SP_IFREQ_FILE);
2938 FILE *f = fopen (fname, NTXT ("r"));
2939 free (fname);
2940 if (f == NULL)
2941 {
2942 ifreqavail = false;
2943 return;
2944 }
2945 ifreqavail = true;
2946 ifreqq = new Emsgqueue (NTXT ("ifreqq"));
2947
2948 while (1)
2949 {
2950 Emsg *m;
2951 char str[MAXPATHLEN];
2952 char *e = fgets (str, ((int) sizeof (str)) - 1, f);
2953 if (e == NULL)
2954 {
2955 // end the list from the experiment
2956 m = new Emsg (CMSG_COMMENT,
2957 GTXT ("============================================================"));
2958 ifreqq->append (m);
2959 break;
2960 }
2961 // get the string
2962 size_t i = strlen (str);
2963 if (i > 0 && str[i - 1] == '\n')
2964 // remove trailing nl
2965 str[i - 1] = 0;
2966 // and append it
2967 m = new Emsg (CMSG_COMMENT, str);
2968 ifreqq->append (m);
2969 }
2970 (void) fclose (f);
2971 }
2972
2973 Experiment *
2974 Experiment::getBaseFounder ()
2975 {
2976 if (baseFounder)
2977 return baseFounder;
2978 Experiment *founder = this;
2979 Experiment *parent = founder->founder_exp;
2980 while (parent)
2981 {
2982 founder = parent;
2983 parent = founder->founder_exp;
2984 }
2985 baseFounder = founder;
2986 return baseFounder;
2987 }
2988
2989 hrtime_t
2990 Experiment::getRelativeStartTime ()
2991 {
2992 if (exp_rel_start_time_set)
2993 return exp_rel_start_time;
2994 Experiment *founder = getBaseFounder ();
2995 hrtime_t child_start = this->getStartTime ();
2996 hrtime_t founder_start = founder->getStartTime ();
2997 exp_rel_start_time = child_start - founder_start;
2998 if (child_start == 0 && founder_start)
2999 exp_rel_start_time = 0; // when descendents have incomplete log.xml
3000 exp_rel_start_time_set = true;
3001 return exp_rel_start_time;
3002 }
3003
3004 DataDescriptor *
3005 Experiment::get_raw_events (int data_id)
3006 {
3007 DataDescriptor *dDscr;
3008 switch (data_id)
3009 {
3010 case DATA_CLOCK:
3011 dDscr = get_profile_events ();
3012 break;
3013 case DATA_SYNCH:
3014 dDscr = get_sync_events ();
3015 break;
3016 case DATA_HWC:
3017 dDscr = get_hwc_events ();
3018 break;
3019 case DATA_HEAP:
3020 dDscr = get_heap_events ();
3021 break;
3022 case DATA_HEAPSZ:
3023 dDscr = get_heapsz_events ();
3024 break;
3025 case DATA_IOTRACE:
3026 dDscr = get_iotrace_events ();
3027 break;
3028 case DATA_RACE:
3029 dDscr = get_race_events ();
3030 break;
3031 case DATA_DLCK:
3032 dDscr = get_deadlock_events ();
3033 break;
3034 case DATA_SAMPLE:
3035 dDscr = get_sample_events ();
3036 break;
3037 case DATA_GCEVENT:
3038 dDscr = get_gc_events ();
3039 break;
3040 default:
3041 dDscr = NULL;
3042 break;
3043 }
3044 return dDscr;
3045 }
3046
3047 int
3048 Experiment::base_data_id (int data_id)
3049 {
3050 switch (data_id)
3051 {
3052 case DATA_HEAPSZ:
3053 return DATA_HEAP; // DATA_HEAPSZ DataView is based on DATA_HEAP's DataView
3054 default:
3055 break;
3056 }
3057 return data_id;
3058 }
3059
3060 DataView *
3061 Experiment::create_derived_data_view (int data_id, DataView *dview)
3062 {
3063 // dview contains filtered packets
3064 switch (data_id)
3065 {
3066 case DATA_HEAPSZ:
3067 return create_heapsz_data_view (dview);
3068 default:
3069 break;
3070 }
3071 return NULL;
3072 }
3073
3074 DataDescriptor *
3075 Experiment::get_profile_events ()
3076 {
3077 DataDescriptor *dDscr = getDataDescriptor (DATA_CLOCK);
3078 if (dDscr == NULL)
3079 return NULL;
3080 if (dDscr->getSize () == 0)
3081 {
3082 char *base_name = get_basename (expt_name);
3083 char *msg = dbe_sprintf (GTXT ("Loading Profile Data: %s"), base_name);
3084 read_data_file (SP_PROFILE_FILE, msg);
3085 free (msg);
3086 add_evt_time_to_profile_events (dDscr);
3087 resolve_frame_info (dDscr);
3088 }
3089 else if (!dDscr->isResolveFrInfoDone ())
3090 resolve_frame_info (dDscr);
3091 return dDscr;
3092 }
3093
3094 void
3095 Experiment::add_evt_time_to_profile_events (DataDescriptor *dDscr)
3096 {
3097 if (coll_params.lms_magic_id != LMS_MAGIC_ID_SOLARIS)
3098 return;
3099
3100 DataView *dview = dDscr->createView ();
3101 dview->sort (PROP_THRID, PROP_TSTAMP);
3102
3103 // add PROP_EVT_TIME
3104 PropDescr* tmp_propDscr = new PropDescr (PROP_EVT_TIME, "EVT_TIME");
3105 tmp_propDscr->uname = dbe_strdup (GTXT ("Event duration"));
3106 tmp_propDscr->vtype = TYPE_INT64;
3107 dDscr->addProperty (tmp_propDscr);
3108
3109 long sz = dview->getSize ();
3110 long long ptimer_usec = get_params ()->ptimer_usec;
3111 for (long i = 0; i < sz; i++)
3112 {
3113 int next_sample;
3114 int jj;
3115 {
3116 hrtime_t this_tstamp = dview->getLongValue (PROP_TSTAMP, i);
3117 long this_thrid = dview->getLongValue (PROP_THRID, i);
3118 for (jj = i + 1; jj < sz; jj++)
3119 {
3120 hrtime_t tmp_tstamp = dview->getLongValue (PROP_TSTAMP, jj);
3121 if (tmp_tstamp != this_tstamp)
3122 break;
3123 long tmp_thrid = dview->getLongValue (PROP_THRID, jj);
3124 if (tmp_thrid != this_thrid)
3125 break;
3126 }
3127 next_sample = jj;
3128 }
3129
3130 long nticks = 0;
3131 for (jj = i; jj < next_sample; jj++)
3132 nticks += dview->getLongValue (PROP_NTICK, jj);
3133 if (nticks <= 1)
3134 continue; // no duration
3135
3136 nticks--;
3137 hrtime_t duration = ptimer_usec * 1000LL * nticks; // nanoseconds
3138 for (jj = i; jj < next_sample; jj++)
3139 dview->setValue (PROP_EVT_TIME, jj, duration);
3140 i = jj - 1;
3141 }
3142 delete dview;
3143 }
3144
3145 DataDescriptor *
3146 Experiment::get_sync_events ()
3147 {
3148 DataDescriptor *dDscr = getDataDescriptor (DATA_SYNCH);
3149 if (dDscr == NULL)
3150 return NULL;
3151 if (dDscr->getSize () > 0)
3152 return dDscr;
3153
3154 // fetch data
3155 {
3156 char *base_name = get_basename (expt_name);
3157 char *msg = dbe_sprintf (GTXT ("Loading Synctrace Data: %s"), base_name);
3158 read_data_file (SP_SYNCTRACE_FILE, msg);
3159 free (msg);
3160 resolve_frame_info (dDscr);
3161 }
3162
3163 // check for PROP_EVT_TIME
3164 PropDescr *tmp_propDscr = dDscr->getProp (PROP_EVT_TIME);
3165 if (tmp_propDscr)
3166 return dDscr;
3167
3168 // add PROP_EVT_TIME
3169 tmp_propDscr = new PropDescr (PROP_EVT_TIME, "EVT_TIME");
3170 tmp_propDscr->uname = dbe_strdup (GTXT ("Event duration"));
3171 tmp_propDscr->vtype = TYPE_INT64;
3172 dDscr->addProperty (tmp_propDscr);
3173
3174 long sz = dDscr->getSize ();
3175 for (long i = 0; i < sz; i++)
3176 {
3177 uint64_t event_duration = dDscr->getLongValue (PROP_TSTAMP, i);
3178 event_duration -= dDscr->getLongValue (PROP_SRQST, i);
3179 dDscr->setValue (PROP_EVT_TIME, i, event_duration);
3180 }
3181 return dDscr;
3182 }
3183
3184 DataDescriptor *
3185 Experiment::get_hwc_events ()
3186 {
3187 DataDescriptor *dDscr = getDataDescriptor (DATA_HWC);
3188 if (dDscr == NULL)
3189 return NULL;
3190 if (dDscr->getSize () == 0)
3191 {
3192 char *base_name = get_basename (expt_name);
3193 char *msg = dbe_sprintf (GTXT ("Loading HW Profile Data: %s"), base_name);
3194
3195 // clear HWC event stats
3196 dsevents = 0;
3197 dsnoxhwcevents = 0;
3198 read_data_file (SP_HWCNTR_FILE, msg);
3199 free (msg);
3200 resolve_frame_info (dDscr);
3201
3202 // describe the HW counters in PropDescr
3203 PropDescr *prop = dDscr->getProp (PROP_HWCTAG);
3204 if (prop)
3205 {
3206 Collection_params *cparam = get_params ();
3207 if (cparam->hw_mode != 0)
3208 for (int aux = 0; aux < MAX_HWCOUNT; aux++)
3209 if (cparam->hw_aux_name[aux])
3210 {
3211 const char* cmdname = cparam->hw_aux_name[aux];
3212 const char* uname = cparam->hw_username[aux];
3213 prop->addState (aux, cmdname, uname);
3214 }
3215 }
3216 else
3217 assert (0);
3218
3219 double dserrrate = 100.0 * ((double) dsnoxhwcevents) / ((double) dsevents);
3220 if ((dsevents > 0) && (dserrrate > 10.0))
3221 {
3222 // warn the user that rate is high
3223 StringBuilder sb;
3224 if (dbeSession->check_ignore_no_xhwcprof ())
3225 sb.sprintf (
3226 GTXT ("Warning: experiment %s has %.1f%%%% (%lld of %lld) dataspace events that were accepted\n without verification; data may be incorrect or misleading\n recompile with -xhwcprof and rerecord to get better data\n"),
3227 base_name, dserrrate, (long long) dsnoxhwcevents,
3228 (long long) dsevents);
3229 else
3230 sb.sprintf (
3231 GTXT ("Warning: experiment %s has %.1f%%%% (%lld of %lld) dataspace events that could not be verified\n recompile with -xhwcprof and rerecord to get better data\n"),
3232 base_name, dserrrate, (long long) dsnoxhwcevents,
3233 (long long) dsevents);
3234 errorq->append (new Emsg (CMSG_WARN, sb));
3235 }
3236
3237 // see if we've scanned the data
3238 if (hwc_scanned == 0)
3239 {
3240 // no, scan the packets to see how many are bogus, or represent lost interrupts
3241 long hwc_cnt = 0;
3242
3243 // loop over the packets, counting the bad ones
3244 if (hwc_bogus != 0 || hwc_lost_int != 0)
3245 {
3246 // hwc counter data had bogus packets and/or packets reflecting lost interrupts
3247 double bogus_rate = 100. * (double) hwc_bogus / (double) hwc_cnt;
3248 if (bogus_rate > 5.)
3249 {
3250 StringBuilder sb;
3251 sb.sprintf (
3252 GTXT ("WARNING: Too many invalid HW counter profile events (%ld/%ld = %3.2f%%) in experiment %d (`%s'); data may be unreliable"),
3253 (long) hwc_bogus, (long) hwc_cnt, bogus_rate,
3254 (int) userExpId, base_name);
3255 Emsg *m = new Emsg (CMSG_WARN, sb);
3256 warnq->append (m);
3257 }
3258 hwc_scanned = 1;
3259 }
3260 }
3261 }
3262 return dDscr;
3263 }
3264
3265 DataDescriptor *
3266 Experiment::get_iotrace_events ()
3267 {
3268 DataDescriptor *dDscr = getDataDescriptor (DATA_IOTRACE);
3269 if (dDscr == NULL)
3270 return NULL;
3271
3272 if (dDscr->getSize () > 0)
3273 return dDscr;
3274
3275 char *base_name = get_basename (expt_name);
3276 char *msg = dbe_sprintf (GTXT ("Loading IO Trace Data: %s"), base_name);
3277 read_data_file (SP_IOTRACE_FILE, msg);
3278 free (msg);
3279
3280 if (dDscr->getSize () == 0)
3281 return dDscr;
3282 resolve_frame_info (dDscr);
3283
3284 // check for PROP_EVT_TIME
3285 PropDescr *tmp_propDscr = dDscr->getProp (PROP_EVT_TIME);
3286 if (tmp_propDscr)
3287 return dDscr;
3288
3289 // add PROP_EVT_TIME
3290 tmp_propDscr = new PropDescr (PROP_EVT_TIME, "EVT_TIME");
3291 tmp_propDscr->uname = dbe_strdup (GTXT ("Event duration"));
3292 tmp_propDscr->vtype = TYPE_INT64;
3293 dDscr->addProperty (tmp_propDscr);
3294
3295 // add PROP_IOVFD
3296 tmp_propDscr = new PropDescr (PROP_IOVFD, "IOVFD");
3297 tmp_propDscr->uname = dbe_strdup (GTXT ("Virtual File Descriptor"));
3298 tmp_propDscr->vtype = TYPE_INT64;
3299 dDscr->addProperty (tmp_propDscr);
3300
3301 delete fDataMap;
3302 fDataMap = new DefaultMap<int64_t, FileData*>;
3303
3304 delete vFdMap;
3305 vFdMap = new DefaultMap<int, int64_t>;
3306
3307 static int64_t virtualFd = 0;
3308
3309 FileData *fData;
3310 virtualFd += 10;
3311 fData = fDataMap->get (VIRTUAL_FD_STDIN);
3312 if (fData == NULL)
3313 {
3314 fData = new FileData (STDIN_FILENAME);
3315 fData->setVirtualFd (VIRTUAL_FD_STDIN);
3316 fData->id = VIRTUAL_FD_STDIN;
3317 fData->setFileDes (STDIN_FD);
3318 fDataMap->put (VIRTUAL_FD_STDIN, fData);
3319 vFdMap->put (STDIN_FD, VIRTUAL_FD_STDIN);
3320 }
3321
3322 fData = fDataMap->get (VIRTUAL_FD_STDOUT);
3323 if (fData == NULL)
3324 {
3325 fData = new FileData (STDOUT_FILENAME);
3326 fData->setVirtualFd (VIRTUAL_FD_STDOUT);
3327 fData->id = VIRTUAL_FD_STDOUT;
3328 fData->setFileDes (STDOUT_FD);
3329 fDataMap->put (VIRTUAL_FD_STDOUT, fData);
3330 vFdMap->put (STDOUT_FD, VIRTUAL_FD_STDOUT);
3331 }
3332
3333 fData = fDataMap->get (VIRTUAL_FD_STDERR);
3334 if (fData == NULL)
3335 {
3336 fData = new FileData (STDERR_FILENAME);
3337 fData->setVirtualFd (VIRTUAL_FD_STDERR);
3338 fData->id = VIRTUAL_FD_STDERR;
3339 fData->setFileDes (STDERR_FD);
3340 fDataMap->put (VIRTUAL_FD_STDERR, fData);
3341 vFdMap->put (STDERR_FD, VIRTUAL_FD_STDERR);
3342 }
3343
3344 fData = fDataMap->get (VIRTUAL_FD_OTHERIO);
3345 if (fData == NULL)
3346 {
3347 fData = new FileData (OTHERIO_FILENAME);
3348 fData->setVirtualFd (VIRTUAL_FD_OTHERIO);
3349 fData->id = VIRTUAL_FD_OTHERIO;
3350 fData->setFileDes (OTHERIO_FD);
3351 fDataMap->put (VIRTUAL_FD_OTHERIO, fData);
3352 }
3353
3354 DataView *dview = dDscr->createView ();
3355 dview->sort (PROP_TSTAMP);
3356 long sz = dview->getSize ();
3357 for (long i = 0; i < sz; i++)
3358 {
3359 hrtime_t event_duration = dview->getLongValue (PROP_TSTAMP, i);
3360 hrtime_t event_start = dview->getLongValue (PROP_IORQST, i);
3361 if (event_start > 0)
3362 event_duration -= event_start;
3363 else
3364 event_duration = 0;
3365 dview->setValue (PROP_EVT_TIME, i, event_duration);
3366
3367 int32_t fd = -1;
3368 int64_t vFd = VIRTUAL_FD_NONE;
3369 char *fName = NULL;
3370 int32_t origFd = -1;
3371 StringBuilder *sb = NULL;
3372 FileData *fDataOrig = NULL;
3373 FileSystem_type fsType;
3374
3375 IOTrace_type ioType = (IOTrace_type) dview->getIntValue (PROP_IOTYPE, i);
3376 switch (ioType)
3377 {
3378 case READ_TRACE:
3379 case WRITE_TRACE:
3380 case READ_TRACE_ERROR:
3381 case WRITE_TRACE_ERROR:
3382 fd = dview->getIntValue (PROP_IOFD, i);
3383 vFd = vFdMap->get (fd);
3384 if (vFd == 0 || vFd == VIRTUAL_FD_NONE
3385 || (fData = fDataMap->get (vFd)) == NULL)
3386 {
3387 fData = new FileData (UNKNOWNFD_FILENAME);
3388 fData->setVirtualFd (virtualFd);
3389 fData->setFsType ("N/A");
3390 fData->setFileDes (fd);
3391 fDataMap->put (virtualFd, fData);
3392 vFdMap->put (fd, virtualFd);
3393 vFd = virtualFd;
3394 virtualFd++;
3395 }
3396 dview->setValue (PROP_IOVFD, i, vFd);
3397 break;
3398 case OPEN_TRACE:
3399 fName = NULL;
3400 sb = (StringBuilder*) dview->getObjValue (PROP_IOFNAME, i);
3401 if (sb != NULL && sb->length () > 0)
3402 fName = sb->toString ();
3403 fd = dview->getIntValue (PROP_IOFD, i);
3404 origFd = dview->getIntValue (PROP_IOOFD, i);
3405 fsType = (FileSystem_type) dview->getIntValue (PROP_IOFSTYPE, i);
3406
3407 if (fName != NULL)
3408 {
3409 fData = new FileData (fName);
3410 fDataMap->put (virtualFd, fData);
3411 vFdMap->put (fd, virtualFd);
3412 fData->setFileDes (fd);
3413 fData->setFsType (fsType);
3414 fData->setVirtualFd (virtualFd);
3415 vFd = virtualFd;
3416 virtualFd++;
3417 }
3418 else if (origFd > 0)
3419 {
3420 vFd = vFdMap->get (origFd);
3421 if (vFd == 0 || vFd == VIRTUAL_FD_NONE)
3422 {
3423 Dprintf (DEBUG_IO,
3424 "*** Error I/O tracing: (open) cannot get the virtual file descriptor, fd=%d origFd=%d\n",
3425 fd, origFd);
3426 continue;
3427 }
3428 else if ((fDataOrig = fDataMap->get (vFd)) == NULL)
3429 {
3430 Dprintf (DEBUG_IO,
3431 "*** Error IO tracing: (open) cannot get original FileData object, fd=%d origFd=%d\n",
3432 fd, origFd);
3433 continue;
3434 }
3435 else
3436 {
3437 fName = fDataOrig->getFileName ();
3438 fData = new FileData (fName);
3439 fData->setFileDes (fd);
3440 fData->setFsType (fDataOrig->getFsType ());
3441 fData->setVirtualFd (virtualFd);
3442 fDataMap->put (virtualFd, fData);
3443 vFdMap->put (fd, virtualFd);
3444 vFd = virtualFd;
3445 virtualFd++;
3446 }
3447 }
3448 else if (fd >= 0)
3449 {
3450 vFd = vFdMap->get (fd);
3451 if (vFd == 0 || vFd == VIRTUAL_FD_NONE
3452 || (fData = fDataMap->get (vFd)) == NULL)
3453 {
3454 fData = new FileData (UNKNOWNFD_FILENAME);
3455 fData->setVirtualFd (virtualFd);
3456 fData->setFsType ("N/A");
3457 fData->setFileDes (fd);
3458 fDataMap->put (virtualFd, fData);
3459 vFdMap->put (fd, virtualFd);
3460 vFd = virtualFd;
3461 virtualFd++;
3462 }
3463 }
3464 else
3465 {
3466 Dprintf (DEBUG_IO,
3467 NTXT ("*** Error IO tracing: (open) unknown open IO type, fd=%d origFd=%d\n"), fd, origFd);
3468 continue;
3469 }
3470
3471 dview->setValue (PROP_IOVFD, i, vFd);
3472 break;
3473
3474 case OPEN_TRACE_ERROR:
3475 fName = NULL;
3476
3477 sb = (StringBuilder*) dview->getObjValue (PROP_IOFNAME, i);
3478 if (sb != NULL && sb->length () > 0)
3479 fName = sb->toString ();
3480 fd = dview->getIntValue (PROP_IOFD, i);
3481 origFd = dview->getIntValue (PROP_IOOFD, i);
3482 fsType = (FileSystem_type) dview->getIntValue (PROP_IOFSTYPE, i);
3483
3484 if (fName != NULL)
3485 {
3486 fData = new FileData (fName);
3487 fDataMap->put (virtualFd, fData);
3488 fData->setFileDes (fd);
3489 fData->setFsType (fsType);
3490 fData->setVirtualFd (virtualFd);
3491 vFd = virtualFd;
3492 virtualFd++;
3493 }
3494 else if (origFd > 0)
3495 {
3496 vFd = vFdMap->get (origFd);
3497 if (vFd == 0 || vFd == VIRTUAL_FD_NONE)
3498 {
3499 Dprintf (DEBUG_IO,
3500 "*** Error IO tracing: (open error) cannot get the virtual file descriptor, fd=%d origFd=%d\n",
3501 fd, origFd);
3502 continue;
3503 }
3504 else if ((fDataOrig = fDataMap->get (vFd)) == NULL)
3505 {
3506 Dprintf (DEBUG_IO,
3507 "*** Error IO tracing: (open error) cannot get original FileData object, fd=%d origFd=%d\n",
3508 fd, origFd);
3509 continue;
3510 }
3511 else
3512 {
3513 fName = fDataOrig->getFileName ();
3514 fData = new FileData (fName);
3515 fData->setFileDes (fd);
3516 fData->setFsType (fDataOrig->getFsType ());
3517 fData->setVirtualFd (virtualFd);
3518 fDataMap->put (virtualFd, fData);
3519 vFd = virtualFd;
3520 virtualFd++;
3521 }
3522 }
3523
3524 dview->setValue (PROP_IOVFD, i, vFd);
3525 break;
3526
3527 case CLOSE_TRACE:
3528 case CLOSE_TRACE_ERROR:
3529 fd = dview->getIntValue (PROP_IOFD, i);
3530 vFd = vFdMap->get (fd);
3531 if (vFd == 0 || vFd == VIRTUAL_FD_NONE)
3532 {
3533 Dprintf (DEBUG_IO,
3534 "*** Error IO tracing: (close) cannot get the virtual file descriptor, fd=%d\n",
3535 fd);
3536 continue;
3537 }
3538 fData = fDataMap->get (vFd);
3539 if (fData == NULL)
3540 {
3541 Dprintf (DEBUG_IO,
3542 "*** Error IO tracing: (close) cannot get the FileData object, fd=%d\n",
3543 fd);
3544 continue;
3545 }
3546
3547 vFdMap->put (fd, VIRTUAL_FD_NONE);
3548 dview->setValue (PROP_IOVFD, i, vFd);
3549 break;
3550
3551 case OTHERIO_TRACE:
3552 case OTHERIO_TRACE_ERROR:
3553 vFd = VIRTUAL_FD_OTHERIO;
3554 fData = fDataMap->get (vFd);
3555 if (fData == NULL)
3556 {
3557 Dprintf (DEBUG_IO,
3558 "*** Error IO tracing: (other IO) cannot get the FileData object\n");
3559 continue;
3560 }
3561
3562 dview->setValue (PROP_IOVFD, i, vFd);
3563 break;
3564 case IOTRACETYPE_LAST:
3565 break;
3566 }
3567 }
3568
3569 delete dview;
3570
3571 return dDscr;
3572 }
3573
3574 DataDescriptor *
3575 Experiment::get_heap_events ()
3576 {
3577 DataDescriptor *dDscr = getDataDescriptor (DATA_HEAP);
3578 if (dDscr == NULL)
3579 return NULL;
3580 if (dDscr->getSize () > 0)
3581 return dDscr;
3582
3583 char *base_name = get_basename (expt_name);
3584 char *msg = dbe_sprintf (GTXT ("Loading Heap Trace Data: %s"), base_name);
3585 read_data_file (SP_HEAPTRACE_FILE, msg);
3586 free (msg);
3587
3588 if (dDscr->getSize () == 0)
3589 return dDscr;
3590 resolve_frame_info (dDscr);
3591
3592 // Match FREE to MALLOC
3593 PropDescr *prop = new PropDescr (PROP_HLEAKED, NTXT ("HLEAKED"));
3594 prop->uname = dbe_strdup (GTXT ("Bytes Leaked"));
3595 prop->vtype = TYPE_UINT64;
3596 dDscr->addProperty (prop);
3597
3598 prop = new PropDescr (PROP_HMEM_USAGE, NTXT ("HMEM_USAGE"));
3599 prop->uname = dbe_strdup (GTXT ("Heap Memory Usage"));
3600 prop->vtype = TYPE_UINT64;
3601 dDscr->addProperty (prop);
3602
3603 prop = new PropDescr (PROP_HFREED, NTXT ("HFREED"));
3604 prop->uname = dbe_strdup (GTXT ("Bytes Freed"));
3605 prop->vtype = TYPE_UINT64;
3606 dDscr->addProperty (prop);
3607
3608 prop = new PropDescr (PROP_HCUR_ALLOCS, NTXT ("HCUR_ALLOCS"));
3609 prop->uname = dbe_strdup (GTXT ("Net Bytes Allocated"));
3610 prop->vtype = TYPE_INT64;
3611 dDscr->addProperty (prop);
3612
3613 prop = new PropDescr (PROP_HCUR_LEAKS, NTXT ("HCUR_LEAKS"));
3614 prop->uname = dbe_strdup (GTXT ("Net Bytes Leaked"));
3615 prop->vtype = TYPE_UINT64;
3616 dDscr->addProperty (prop);
3617
3618 prop = new PropDescr (PROP_HCUR_NET_ALLOC, NTXT ("HCUR_NET_ALLOC"));
3619 prop->vtype = TYPE_INT64;
3620 prop->flags = DDFLAG_NOSHOW;
3621 dDscr->addProperty (prop);
3622
3623 prop = new PropDescr (PROP_DDSCR_LNK, NTXT ("DDSCR_LNK"));
3624 prop->vtype = TYPE_UINT64;
3625 prop->flags = DDFLAG_NOSHOW;
3626 dDscr->addProperty (prop);
3627
3628 prop = new PropDescr (PROP_VOIDP_OBJ, NTXT ("VOIDP_OBJ"));
3629 prop->vtype = TYPE_OBJ;
3630 prop->flags = DDFLAG_NOSHOW;
3631 dDscr->addProperty (prop);
3632
3633 prop = new PropDescr (PROP_TSTAMP2, NTXT ("TSTAMP2"));
3634 prop->uname = dbe_strdup (GTXT ("End Timestamp (nanoseconds)"));
3635 prop->vtype = TYPE_UINT64;
3636 prop->flags = DDFLAG_NOSHOW;
3637 dDscr->addProperty (prop);
3638
3639 DataView *dview = dDscr->createView ();
3640 dview->sort (PROP_TSTAMP);
3641
3642 // Keep track of memory usage
3643 Size memoryUsage = 0;
3644
3645 HeapMap *heapmap = new HeapMap ();
3646 long sz = dview->getSize ();
3647 for (long i = 0; i < sz; i++)
3648 {
3649
3650 Heap_type mtype = (Heap_type) dview->getIntValue (PROP_HTYPE, i);
3651 Vaddr vaddr = dview->getULongValue (PROP_HVADDR, i);
3652 Vaddr ovaddr = dview->getULongValue (PROP_HOVADDR, i);
3653 Size hsize = dview->getULongValue (PROP_HSIZE, i);
3654 hrtime_t tstamp = dview->getLongValue (PROP_TSTAMP, i);
3655
3656 switch (mtype)
3657 {
3658 case MALLOC_TRACE:
3659 dview->setValue (PROP_TSTAMP2, i, (uint64_t) MAX_TIME);
3660 if (vaddr)
3661 {
3662 dview->setValue (PROP_HLEAKED, i, hsize);
3663 heapmap->allocate (vaddr, i + 1);
3664
3665 // Increase heap size
3666 memoryUsage += hsize;
3667 dview->setValue (PROP_HMEM_USAGE, i, memoryUsage);
3668 }
3669 break;
3670
3671 case FREE_TRACE:
3672 if (vaddr)
3673 {
3674 long idx = heapmap->deallocate (vaddr) - 1;
3675 if (idx >= 0)
3676 {
3677 // Decrease heap size
3678 Size leaked = dview->getLongValue (PROP_HLEAKED, idx);
3679 memoryUsage -= leaked;
3680 dview->setValue (PROP_HMEM_USAGE, i, memoryUsage);
3681
3682 Size alloc = dview->getLongValue (PROP_HSIZE, idx);
3683 // update allocation
3684 dview->setValue (PROP_HLEAKED, idx, (uint64_t) 0);
3685 dview->setValue (PROP_TSTAMP2, idx, tstamp);
3686 dview->setValue (PROP_DDSCR_LNK, idx, dview->getIdByIdx (i) + 1);
3687 // update this event
3688 dview->setValue (PROP_HFREED, i, alloc);
3689 }
3690 }
3691 break;
3692
3693 case REALLOC_TRACE:
3694 dview->setValue (PROP_TSTAMP2, i, (uint64_t) MAX_TIME);
3695 if (ovaddr)
3696 {
3697 long idx = heapmap->deallocate (ovaddr) - 1;
3698 if (idx >= 0)
3699 {
3700 // Decrease heap size
3701 Size leaked = dview->getLongValue (PROP_HLEAKED, idx);
3702 memoryUsage -= leaked;
3703 dview->setValue (PROP_HMEM_USAGE, i, memoryUsage);
3704
3705 Size alloc = dview->getLongValue (PROP_HSIZE, idx);
3706 // update allocation
3707 dview->setValue (PROP_HLEAKED, idx, (uint64_t) 0);
3708 dview->setValue (PROP_TSTAMP2, idx, tstamp);
3709 dview->setValue (PROP_DDSCR_LNK, idx, dview->getIdByIdx (i) + 1);
3710 // update this event
3711 dview->setValue (PROP_HFREED, i, alloc);
3712 }
3713 }
3714 if (vaddr)
3715 {
3716 dview->setValue (PROP_HLEAKED, i, hsize);
3717 heapmap->allocate (vaddr, i + 1);
3718
3719 // Increase heap size
3720 memoryUsage += hsize;
3721 dview->setValue (PROP_HMEM_USAGE, i, memoryUsage);
3722 }
3723 break;
3724 case MMAP_TRACE:
3725 case MUNMAP_TRACE:
3726 // Adjust the size to be multiple of page_size
3727 //hsize = (( hsize - 1 ) / page_size + 1 ) * page_size;
3728 if (vaddr)
3729 {
3730 UnmapChunk *list;
3731 if (mtype == MMAP_TRACE)
3732 {
3733 dview->setValue (PROP_TSTAMP2, i, (uint64_t) MAX_TIME);
3734 dview->setValue (PROP_HLEAKED, i, hsize);
3735 list = heapmap->mmap (vaddr, hsize, i);
3736
3737 // Increase heap size
3738 memoryUsage += hsize;
3739 dview->setValue (PROP_HMEM_USAGE, i, memoryUsage);
3740 }
3741 else
3742 { // MUNMAP_TRACE
3743 list = heapmap->munmap (vaddr, hsize);
3744
3745 // Set allocation size to zero
3746 // Note: We're currently reusing PROP_HSIZE to mean allocation size
3747 // If we ever need to save the original HSIZE, we'll need to
3748 // create a new PROP_* to represent event allocation size
3749 //
3750 // For now, tuck the original size away as HOVADDR
3751 dview->setValue (PROP_HOVADDR, i, (uint64_t) hsize);
3752 dview->setValue (PROP_HSIZE, i, (uint64_t) 0);
3753 }
3754 Size total_freed = 0;
3755 while (list)
3756 {
3757 long idx = list->val;
3758 total_freed += list->size;
3759 Size leaked = dview->getLongValue (PROP_HLEAKED, idx);
3760
3761 // Decrease heap size
3762 memoryUsage -= list->size;
3763 dview->setValue (PROP_HMEM_USAGE, i, memoryUsage);
3764
3765 Size leak_update = leaked - list->size;
3766 // update allocation
3767 dview->setValue (PROP_HLEAKED, idx, leak_update);
3768 // update allocation's list of frees
3769 {
3770 UnmapChunk *copy = new UnmapChunk;
3771 heapUnmapEvents->append (copy);
3772 copy->val = dview->getIdByIdx (i);
3773 copy->size = list->size;
3774 copy->next = (UnmapChunk *) dview->getObjValue (PROP_VOIDP_OBJ, idx);
3775 dview->setObjValue (PROP_VOIDP_OBJ, idx, copy);
3776 }
3777 if (leak_update <= 0)
3778 if (leak_update == 0)
3779 dview->setValue (PROP_TSTAMP2, idx, tstamp);
3780 UnmapChunk *t = list;
3781 list = list->next;
3782 delete t;
3783 }
3784 // update this event
3785 if (total_freed)
3786 // only need to write value if it is non-zero
3787 dview->setValue (PROP_HFREED, i, total_freed);
3788 }
3789 break;
3790 // ignoring HEAPTYPE_LAST, which will never be recorded
3791 case HEAPTYPE_LAST:
3792 break;
3793 }
3794 }
3795 delete heapmap;
3796 delete dview;
3797
3798 return dDscr;
3799 }
3800
3801 DataDescriptor *
3802 Experiment::get_heapsz_events ()
3803 {
3804 DataDescriptor *dDscr = getDataDescriptor (DATA_HEAPSZ);
3805 if (dDscr)
3806 return dDscr;
3807 dDscr = get_heap_events (); // derived from DATA_HEAP
3808 if (dDscr == NULL)
3809 return NULL;
3810 dDscr = newDataDescriptor (DATA_HEAPSZ, 0, dDscr);
3811 return dDscr;
3812 }
3813
3814 static void
3815 update_heapsz_packet (std::set<long> &pkt_id_set, DataView *dview,
3816 long alloc_pkt_id, int64_t net_alloc, uint64_t leaks)
3817 {
3818 // pkt_id_set: set is updated to include packet
3819 // alloc_pkt_id: data descriptor id (NOT dview idx)
3820 // net_alloc: adjustment to net allocation for this packet (note: signed value)
3821 // leaks: leak bytes to attribute to alloc_pkt_id
3822 std::pair < std::set<long>::iterator, bool> ret;
3823 ret = pkt_id_set.insert (alloc_pkt_id); // add to set
3824 bool new_to_set = ret.second; // was not in set
3825 if (!new_to_set)
3826 {
3827 // Has been seen before, update values
3828 net_alloc += dview->getDataDescriptorValue (PROP_HCUR_NET_ALLOC, alloc_pkt_id);
3829 if (leaks)
3830 {
3831 uint64_t old = dview->getDataDescriptorValue (PROP_HCUR_LEAKS, alloc_pkt_id);
3832 if (old != 0)
3833 leaks = old;
3834 }
3835 }
3836 dview->setDataDescriptorValue (PROP_HCUR_NET_ALLOC, alloc_pkt_id, net_alloc);
3837 dview->setDataDescriptorValue (PROP_HCUR_LEAKS, alloc_pkt_id, leaks);
3838 }
3839
3840 DataView *
3841 Experiment::create_heapsz_data_view (DataView *heap_dview)
3842 {
3843 // heap_dview has DATA_HEAP _filtered_ packets.
3844 // This creates, populates, and returns DATA_HEAPSZ DataView
3845 DataDescriptor *dDscr = get_heapsz_events ();
3846 if (dDscr == NULL)
3847 return NULL;
3848 std::set<long> pkt_id_set;
3849 DataView *dview = heap_dview;
3850 long sz = dview->getSize ();
3851 for (long i = 0; i < sz; i++)
3852 {
3853 int64_t hsize = (int64_t) dview->getULongValue (PROP_HSIZE, i);
3854 uint64_t leaks = dview->getULongValue (PROP_HLEAKED, i);
3855 long alloc_pkt_id = dview->getIdByIdx (i);
3856 update_heapsz_packet (pkt_id_set, dview, alloc_pkt_id, hsize, leaks);
3857
3858 // linked free
3859 UnmapChunk *mmap_frees = (UnmapChunk *) dview->getObjValue (PROP_VOIDP_OBJ, i); // mmap metadata
3860 if (mmap_frees)
3861 {
3862 // mmap: all frees associated with this packet
3863 while (mmap_frees)
3864 {
3865 long free_pkt_id = mmap_frees->val;
3866 int64_t free_sz = mmap_frees->size;
3867 update_heapsz_packet (pkt_id_set, dview, free_pkt_id, -free_sz, 0);
3868 mmap_frees = mmap_frees->next;
3869 }
3870 }
3871 else
3872 {
3873 // malloc: check for associated free
3874 long free_pkt_id = dview->getLongValue (PROP_DDSCR_LNK, i) - 1;
3875 if (free_pkt_id >= 0)
3876 update_heapsz_packet (pkt_id_set, dview, free_pkt_id, -hsize, 0);
3877 }
3878 }
3879
3880 // create a new DataView based on the filtered-in and associated free events
3881 std::set<long>::iterator it;
3882 DataView *heapsz_dview = dDscr->createExtManagedView ();
3883 for (it = pkt_id_set.begin (); it != pkt_id_set.end (); ++it)
3884 {
3885 long ddscr_pkt_id = *it;
3886 heapsz_dview->appendDataDescriptorId (ddscr_pkt_id);
3887 }
3888 compute_heapsz_data_view (heapsz_dview);
3889 return heapsz_dview;
3890 }
3891
3892 void
3893 Experiment::compute_heapsz_data_view (DataView *heapsz_dview)
3894 {
3895 DataView *dview = heapsz_dview;
3896
3897 // Keep track of memory usage
3898 int64_t currentAllocs = 0;
3899 Size currentLeaks = 0;
3900 dview->sort (PROP_TSTAMP);
3901 long sz = dview->getSize ();
3902 for (long i = 0; i < sz; i++)
3903 {
3904 int64_t net_alloc = dview->getLongValue (PROP_HCUR_NET_ALLOC, i);
3905 currentAllocs += net_alloc;
3906 dview->setValue (PROP_HCUR_ALLOCS, i, currentAllocs);
3907
3908 Size leaks = dview->getULongValue (PROP_HCUR_LEAKS, i);
3909 currentLeaks += leaks;
3910 dview->setValue (PROP_HCUR_LEAKS, i, currentLeaks);
3911 }
3912 }
3913
3914 void
3915 Experiment::DBG_memuse (Sample * s)
3916 {
3917 DataDescriptor *dDscr = getDataDescriptor (DATA_HEAP);
3918 if (dDscr == NULL || dDscr->getSize () == 0)
3919 return;
3920
3921 DataView *dview = dDscr->createView ();
3922 dview->sort (PROP_TSTAMP);
3923 hrtime_t ts1 = s->get_start_time ();
3924 hrtime_t ts2 = s->get_end_time ();
3925
3926 HeapMap *heapmap = new HeapMap ();
3927 long sz = dview->getSize ();
3928 Size maxSize = 0;
3929 Size curSize = 0;
3930 hrtime_t maxTime = 0;
3931 for (long i = 0; i < sz; i++)
3932 {
3933 hrtime_t tstamp = dview->getLongValue (PROP_TSTAMP, i);
3934 if (tstamp < ts1)
3935 continue;
3936 if (tstamp >= ts2)
3937 break;
3938
3939 Heap_type mtype = (Heap_type) dview->getIntValue (PROP_HTYPE, i);
3940 Vaddr vaddr = dview->getULongValue (PROP_HVADDR, i);
3941 Vaddr ovaddr = dview->getULongValue (PROP_HOVADDR, i);
3942 switch (mtype)
3943 {
3944 case REALLOC_TRACE:
3945 break;
3946 case MALLOC_TRACE:
3947 ovaddr = 0;
3948 break;
3949 case FREE_TRACE:
3950 ovaddr = vaddr;
3951 vaddr = 0;
3952 break;
3953 default:
3954 vaddr = 0;
3955 ovaddr = 0;
3956 break;
3957 }
3958 if (ovaddr)
3959 {
3960 long idx = heapmap->deallocate (ovaddr) - 1;
3961 if (idx >= 0)
3962 curSize -= dview->getULongValue (PROP_HSIZE, idx);
3963 }
3964 if (vaddr)
3965 {
3966 heapmap->allocate (vaddr, i + 1);
3967 curSize += dview->getULongValue (PROP_HSIZE, i);
3968 if (curSize > maxSize)
3969 {
3970 maxSize = curSize;
3971 maxTime = tstamp;
3972 }
3973 }
3974 }
3975 printf ("SAMPLE=%s (id=%d) MEMUSE=%lld TSTAMP=%lld\n", s->get_start_label (),
3976 s->get_number (), maxSize, maxTime - getStartTime ());
3977 delete dview;
3978 delete heapmap;
3979 }
3980
3981 void
3982 Experiment::DBG_memuse (const char *sname)
3983 {
3984 for (int i = 0; i < samples->size (); ++i)
3985 {
3986 Sample *sample = samples->fetch (i);
3987 if (streq (sname, sample->get_start_label ()))
3988 {
3989 DBG_memuse (sample);
3990 break;
3991 }
3992 }
3993 }
3994
3995 DataDescriptor *
3996 Experiment::get_race_events ()
3997 {
3998 DataDescriptor *dDscr = getDataDescriptor (DATA_RACE);
3999 if (dDscr == NULL)
4000 return NULL;
4001 if (dDscr->getSize () == 0)
4002 {
4003 char *base_name = get_basename (expt_name);
4004 char *msg = dbe_sprintf (GTXT ("Loading Race Data: %s"), base_name);
4005 read_data_file (SP_RACETRACE_FILE, msg);
4006 free (msg);
4007 resolve_frame_info (dDscr);
4008 }
4009 return dDscr;
4010 }
4011
4012 DataDescriptor *
4013 Experiment::get_deadlock_events ()
4014 {
4015 DataDescriptor *dDscr = getDataDescriptor (DATA_DLCK);
4016 if (dDscr == NULL)
4017 return NULL;
4018 if (dDscr->getSize () == 0)
4019 {
4020 char *base_name = get_basename (expt_name);
4021 char *msg = dbe_sprintf (GTXT ("Loading Deadlocks Data: %s"), base_name);
4022 read_data_file (SP_DEADLOCK_FILE, msg);
4023 free (msg);
4024 resolve_frame_info (dDscr);
4025 }
4026 return dDscr;
4027 }
4028
4029 DataDescriptor *
4030 Experiment::get_sample_events ()
4031 {
4032 DataDescriptor *dDscr = getDataDescriptor (DATA_SAMPLE);
4033 if (dDscr == NULL)
4034 return NULL;
4035 if (dDscr->getSize () > 0)
4036 return dDscr;
4037
4038 // read_overview_file(); //YXXX do this here at some point instead of:
4039 PropDescr *tmp_propDscr;
4040 tmp_propDscr = new PropDescr (PROP_SMPLOBJ, NTXT ("SMPLOBJ"));
4041 tmp_propDscr->uname = NULL;
4042 tmp_propDscr->vtype = TYPE_OBJ;
4043 dDscr->addProperty (tmp_propDscr);
4044
4045 tmp_propDscr = new PropDescr (PROP_TSTAMP, NTXT ("TSTAMP"));
4046 tmp_propDscr->uname = dbe_strdup ("High resolution timestamp");
4047 tmp_propDscr->vtype = TYPE_UINT64;
4048 dDscr->addProperty (tmp_propDscr);
4049
4050 tmp_propDscr = new PropDescr (PROP_SAMPLE, NTXT ("SAMPLE"));
4051 tmp_propDscr->uname = dbe_strdup ("Sample number");
4052 tmp_propDscr->vtype = TYPE_UINT64;
4053 dDscr->addProperty (tmp_propDscr);
4054
4055 tmp_propDscr = new PropDescr (PROP_EVT_TIME, NTXT ("EVT_TIME"));
4056 tmp_propDscr->uname = dbe_strdup ("Event duration");
4057 tmp_propDscr->vtype = TYPE_UINT64;
4058 dDscr->addProperty (tmp_propDscr);
4059
4060 long ssize = samples->size ();
4061 for (long ii = 0; ii < ssize; ii++)
4062 {
4063 Sample * sample = samples->fetch (ii);
4064 long recn = dDscr->addRecord ();
4065 hrtime_t sduration = sample->get_end_time () - sample->get_start_time ();
4066 dDscr->setObjValue (PROP_SMPLOBJ, recn, sample);
4067 dDscr->setValue (PROP_SAMPLE, recn, sample->get_number ());
4068 dDscr->setValue (PROP_TSTAMP, recn, sample->get_end_time ());
4069 dDscr->setValue (PROP_EVT_TIME, recn, sduration);
4070 }
4071 return dDscr;
4072 }
4073
4074 DataDescriptor *
4075 Experiment::get_gc_events ()
4076 {
4077 DataDescriptor *dDscr = getDataDescriptor (DATA_GCEVENT);
4078 if (dDscr == NULL)
4079 return NULL;
4080 if (dDscr->getSize () > 0)
4081 return dDscr;
4082
4083 // read_overview_file(); //YXXX do this here at some point instead of:
4084 PropDescr *tmp_propDscr;
4085 tmp_propDscr = new PropDescr (PROP_GCEVENTOBJ, NTXT ("GCEVENTOBJ"));
4086 tmp_propDscr->uname = NULL;
4087 tmp_propDscr->vtype = TYPE_OBJ;
4088 dDscr->addProperty (tmp_propDscr);
4089
4090 tmp_propDscr = new PropDescr (PROP_TSTAMP, NTXT ("TSTAMP"));
4091 tmp_propDscr->uname = dbe_strdup ("High resolution timestamp");
4092 tmp_propDscr->vtype = TYPE_UINT64;
4093 dDscr->addProperty (tmp_propDscr);
4094
4095 tmp_propDscr = new PropDescr (PROP_GCEVENT, NTXT ("GCEVENT"));
4096 tmp_propDscr->uname = dbe_strdup ("GCEvent number");
4097 tmp_propDscr->vtype = TYPE_UINT64;
4098 dDscr->addProperty (tmp_propDscr);
4099
4100 tmp_propDscr = new PropDescr (PROP_EVT_TIME, NTXT ("EVT_TIME"));
4101 tmp_propDscr->uname = dbe_strdup ("Event duration");
4102 tmp_propDscr->vtype = TYPE_UINT64;
4103 dDscr->addProperty (tmp_propDscr);
4104
4105 long ssize = gcevents->size ();
4106 for (long ii = 0; ii < ssize; ii++)
4107 {
4108 GCEvent * gcevent = gcevents->fetch (ii);
4109 long recn = dDscr->addRecord ();
4110 hrtime_t sduration = gcevent->end - gcevent->start;
4111 dDscr->setObjValue (PROP_GCEVENTOBJ, recn, gcevent);
4112 dDscr->setValue (PROP_GCEVENT, recn, gcevent->id);
4113 dDscr->setValue (PROP_TSTAMP, recn, gcevent->end);
4114 dDscr->setValue (PROP_EVT_TIME, recn, sduration);
4115 }
4116 return dDscr;
4117 }
4118
4119 void
4120 Experiment::update_last_event (hrtime_t ts/*wall_ts*/)
4121 {
4122 if (last_event == ZERO_TIME)
4123 {
4124 // not yet initialized
4125 last_event = ts;
4126 }
4127 if (last_event - exp_start_time < ts - exp_start_time)
4128 // compare deltas to avoid hrtime_t wrap
4129 last_event = ts;
4130 }
4131
4132 void
4133 Experiment::write_header ()
4134 {
4135 StringBuilder sb;
4136
4137 // write commentary to the experiment, describing the parameters
4138 if (dbeSession->ipc_mode || dbeSession->rdt_mode)
4139 {
4140 // In GUI: print start time at the beginning
4141 time_t t = (time_t) start_sec;
4142 char *start_time = ctime (&t);
4143 if (start_time != NULL)
4144 {
4145 sb.setLength (0);
4146 sb.sprintf (GTXT ("Experiment started %s"), start_time);
4147 commentq->append (new Emsg (CMSG_COMMENT, sb));
4148 }
4149 }
4150 // write message with target arglist
4151 if (uarglist != NULL)
4152 {
4153 sb.setLength (0);
4154 sb.sprintf (GTXT ("\nTarget command (%s): '%s'"),
4155 (wsize == W32 ? "32-bit" : "64-bit"), uarglist);
4156 commentq->append (new Emsg (CMSG_COMMENT, sb));
4157 }
4158
4159 sb.setLength (0);
4160 sb.sprintf (GTXT ("Process pid %d, ppid %d, pgrp %d, sid %d"),
4161 pid, ppid, pgrp, sid);
4162 commentq->append (new Emsg (CMSG_COMMENT, sb));
4163
4164 // add comment for user name, if set
4165 if (username != NULL)
4166 {
4167 sb.setLength (0);
4168 sb.sprintf (GTXT ("User: `%s'"), username);
4169 commentq->append (new Emsg (CMSG_COMMENT, sb));
4170 }
4171
4172 // add comment for current working directory
4173 if (ucwd != NULL)
4174 {
4175 sb.setLength (0);
4176 sb.sprintf (GTXT ("Current working directory: %s"), ucwd);
4177 commentq->append (new Emsg (CMSG_COMMENT, sb));
4178 }
4179
4180 // add comment for collector version string
4181 if (cversion != NULL)
4182 {
4183 char *wstring;
4184 switch (wsize)
4185 {
4186 case Wnone:
4187 wstring = NTXT ("?");
4188 break;
4189 case W32:
4190 wstring = GTXT ("32-bit");
4191 break;
4192 case W64:
4193 wstring = GTXT ("64-bit");
4194 break;
4195 default:
4196 wstring = NTXT ("??");
4197 break;
4198 }
4199 sb.setLength (0);
4200 sb.sprintf (GTXT ("Collector version: `%s'; experiment version %d.%d (%s)"),
4201 cversion, exp_maj_version, exp_min_version, wstring);
4202 commentq->append (new Emsg (CMSG_COMMENT, sb));
4203 }
4204
4205 // add comment for driver version string (er_kernel)
4206 if (dversion != NULL)
4207 {
4208 sb.setLength (0);
4209 sb.sprintf (GTXT ("Kernel driver version: `%s'"), dversion);
4210 commentq->append (new Emsg (CMSG_COMMENT, sb));
4211 }
4212
4213 if (jversion != NULL)
4214 {
4215 sb.setLength (0);
4216 sb.sprintf (GTXT ("JVM version: `%s'"), jversion);
4217 commentq->append (new Emsg (CMSG_COMMENT, sb));
4218 }
4219
4220 // add comment for hostname, parameters
4221 if (hostname == NULL)
4222 hostname = dbe_strdup (GTXT ("unknown"));
4223 if (os_version == NULL)
4224 os_version = dbe_strdup (GTXT ("unknown"));
4225 if (architecture == NULL)
4226 architecture = dbe_strdup (GTXT ("unknown"));
4227 sb.setLength (0);
4228 sb.sprintf (GTXT ("Host `%s', OS `%s', page size %d, architecture `%s'"),
4229 hostname, os_version, page_size, architecture);
4230 commentq->append (new Emsg (CMSG_COMMENT, sb));
4231
4232 sb.setLength (0);
4233 if (maxclock != minclock)
4234 {
4235 clock = maxclock;
4236 sb.sprintf (
4237 GTXT (" %d CPUs, with clocks ranging from %d to %d MHz.; max of %d MHz. assumed"),
4238 ncpus, minclock, maxclock, clock);
4239 }
4240 else
4241 sb.sprintf (GTXT (" %d CPU%s, clock speed %d MHz."),
4242 ncpus, (ncpus == 1 ? NTXT ("") : "s"), clock);
4243 commentq->append (new Emsg (CMSG_COMMENT, sb));
4244
4245 // add comment for machine memory size
4246 if (page_size > 0 && npages > 0)
4247 {
4248 long long memsize = ((long long) npages * page_size) / (1024 * 1024);
4249 sb.setLength (0);
4250 sb.sprintf (GTXT (" Memory: %d pages @ %d = %lld MB."),
4251 npages, page_size, memsize);
4252 commentq->append (new Emsg (CMSG_COMMENT, sb));
4253 }
4254
4255 // add comment for machine memory size
4256 if (machinemodel != NULL)
4257 {
4258 sb.setLength (0);
4259 sb.sprintf (GTXT (" Machine model: %s"), machinemodel);
4260 commentq->append (new Emsg (CMSG_COMMENT, sb));
4261 }
4262
4263 // add comment for start time
4264 time_t t = (time_t) start_sec;
4265 char *p = ctime (&t);
4266 sb.setLength (0);
4267 if (p != NULL)
4268 sb.sprintf (GTXT ("Experiment started %s"), p);
4269 else
4270 sb.sprintf (GTXT ("\nExperiment start not recorded"));
4271 write_coll_params ();
4272 commentq->append (new Emsg (CMSG_COMMENT, sb));
4273 commentq->appendqueue (runlogq);
4274 runlogq->mark_clear ();
4275 }
4276
4277 void
4278 Experiment::write_coll_params ()
4279 {
4280 StringBuilder sb;
4281
4282 // now write the various collection parameters as comments
4283 sb.setLength (0);
4284 sb.append (GTXT ("Data collection parameters:"));
4285 commentq->append (new Emsg (CMSG_COMMENT, sb));
4286 if (coll_params.profile_mode == 1)
4287 {
4288 sb.setLength (0);
4289 sb.sprintf (GTXT (" Clock-profiling, interval = %d microsecs."),
4290 (int) (coll_params.ptimer_usec));
4291 commentq->append (new Emsg (CMSG_COMMENT, sb));
4292 }
4293 if (coll_params.sync_mode == 1)
4294 {
4295 sb.setLength (0);
4296 char *scope_str = NTXT ("");
4297 switch (coll_params.sync_scope)
4298 {
4299 case 0:
4300 scope_str = GTXT ("Native- and Java-APIs");
4301 break;
4302 case SYNCSCOPE_JAVA:
4303 scope_str = GTXT ("JAVA-APIs");
4304 break;
4305 case SYNCSCOPE_NATIVE:
4306 scope_str = GTXT ("Native-APIs");
4307 break;
4308 case SYNCSCOPE_JAVA | SYNCSCOPE_NATIVE:
4309 scope_str = GTXT ("Native- and Java-APIs");
4310 break;
4311 }
4312 if (coll_params.sync_threshold < 0)
4313 sb.sprintf (GTXT (" Synchronization tracing, threshold = %d microsecs. (calibrated); %s"),
4314 -coll_params.sync_threshold, scope_str);
4315 else
4316 sb.sprintf (GTXT (" Synchronization tracing, threshold = %d microsecs.; %s"),
4317 coll_params.sync_threshold, scope_str);
4318 commentq->append (new Emsg (CMSG_COMMENT, sb));
4319 }
4320 if (coll_params.heap_mode == 1)
4321 {
4322 sb.setLength (0);
4323 sb.append (GTXT (" Heap tracing"));
4324 commentq->append (new Emsg (CMSG_COMMENT, sb));
4325 }
4326 if (coll_params.io_mode == 1)
4327 {
4328 sb.setLength (0);
4329 sb.append (GTXT (" IO tracing"));
4330 commentq->append (new Emsg (CMSG_COMMENT, sb));
4331 }
4332 if (coll_params.race_mode == 1)
4333 {
4334 sb.setLength (0);
4335 char *race_stack_name;
4336 switch (coll_params.race_stack)
4337 {
4338 case 0:
4339 race_stack_name = GTXT ("dual-stack");
4340 break;
4341 case 1:
4342 race_stack_name = GTXT ("single-stack");
4343 break;
4344 case 2:
4345 race_stack_name = GTXT ("leaf");
4346 break;
4347 default:
4348 abort ();
4349 }
4350 sb.sprintf (GTXT (" Datarace detection, %s"), race_stack_name);
4351 commentq->append (new Emsg (CMSG_COMMENT, sb));
4352 }
4353 if (coll_params.deadlock_mode == 1)
4354 {
4355 sb.setLength (0);
4356 sb.append (GTXT (" Deadlock detection"));
4357 commentq->append (new Emsg (CMSG_COMMENT, sb));
4358 }
4359 if (coll_params.hw_mode == 1)
4360 {
4361 sb.setLength (0);
4362 if (hwc_default == true)
4363 sb.append (GTXT (" HW counter-profiling (default); counters:"));
4364 else
4365 sb.append (GTXT (" HW counter-profiling; counters:"));
4366 commentq->append (new Emsg (CMSG_COMMENT, sb));
4367 for (int i = 0; i < MAX_HWCOUNT; i++)
4368 {
4369 if (!coll_params.hw_aux_name[i])
4370 continue;
4371 sb.setLength (0);
4372 sb.sprintf (GTXT (" %s, tag %d, interval %d, memop %d"),
4373 coll_params.hw_aux_name[i], i,
4374 coll_params.hw_interval[i], coll_params.hw_tpc[i]);
4375 commentq->append (new Emsg (CMSG_COMMENT, sb));
4376 }
4377 }
4378 if (coll_params.sample_periodic == 1)
4379 {
4380 sb.setLength (0);
4381 sb.sprintf (GTXT (" Periodic sampling, %d secs."),
4382 coll_params.sample_timer);
4383 commentq->append (new Emsg (CMSG_COMMENT, sb));
4384 }
4385 if (coll_params.limit != 0)
4386 {
4387 sb.setLength (0);
4388 sb.sprintf (GTXT (" Experiment size limit, %d"),
4389 coll_params.limit);
4390 commentq->append (new Emsg (CMSG_COMMENT, sb));
4391 }
4392 if (coll_params.linetrace != NULL)
4393 {
4394 sb.setLength (0);
4395 sb.sprintf (GTXT (" Follow descendant processes from: %s"),
4396 coll_params.linetrace);
4397 commentq->append (new Emsg (CMSG_COMMENT, sb));
4398 }
4399 if (coll_params.pause_sig != NULL)
4400 {
4401 sb.setLength (0);
4402 sb.sprintf (GTXT (" Pause signal %s"), coll_params.pause_sig);
4403 commentq->append (new Emsg (CMSG_COMMENT, sb));
4404 }
4405 if (coll_params.sample_sig != NULL)
4406 {
4407 sb.setLength (0);
4408 sb.sprintf (GTXT (" Sample signal %s"), coll_params.sample_sig);
4409 commentq->append (new Emsg (CMSG_COMMENT, sb));
4410 }
4411 if (coll_params.start_delay != NULL)
4412 {
4413 sb.setLength (0);
4414 sb.sprintf (GTXT (" Data collection delay start %s seconds"), coll_params.start_delay);
4415 commentq->append (new Emsg (CMSG_COMMENT, sb));
4416 }
4417 if (coll_params.terminate != NULL)
4418 {
4419 sb.setLength (0);
4420 sb.sprintf (GTXT (" Data collection termination after %s seconds"), coll_params.terminate);
4421 commentq->append (new Emsg (CMSG_COMMENT, sb));
4422 }
4423 // add a blank line after data description
4424 commentq->append (new Emsg (CMSG_COMMENT, NTXT ("")));
4425 }
4426
4427
4428 /*
4429 * Raw packet processing
4430 */
4431 static int
4432 check_mstate (char *ptr, PacketDescriptor *pDscr, int arg)
4433 {
4434 switch (arg)
4435 {
4436 case PROP_UCPU:
4437 case PROP_SCPU:
4438 case PROP_TRAP:
4439 case PROP_TFLT:
4440 case PROP_DFLT:
4441 case PROP_KFLT:
4442 case PROP_ULCK:
4443 case PROP_TSLP:
4444 case PROP_WCPU:
4445 case PROP_TSTP:
4446 break;
4447 default:
4448 return 0;
4449 }
4450 Vector<FieldDescr*> *fields = pDscr->getFields ();
4451 for (int i = 0, sz = fields->size (); i < sz; i++)
4452 {
4453 FieldDescr *fDscr = fields->fetch (i);
4454 if (fDscr->propID == arg)
4455 return *((int*) (ptr + fDscr->offset));
4456 }
4457 return 0;
4458 }
4459
4460 #define PACKET_ALIGNMENT 4
4461
4462 uint64_t
4463 Experiment::readPacket (Data_window *dwin, Data_window::Span *span)
4464 {
4465 Common_packet *rcp = (Common_packet *) dwin->bind (span,
4466 sizeof (CommonHead_packet));
4467 uint16_t v16;
4468 uint64_t size = 0;
4469 if (rcp)
4470 {
4471 if ((((long) rcp) % PACKET_ALIGNMENT) != 0)
4472 {
4473 invalid_packet++;
4474 size = PROFILE_BUFFER_CHUNK - span->offset % PROFILE_BUFFER_CHUNK;
4475 return size;
4476 }
4477 v16 = (uint16_t) rcp->tsize;
4478 size = dwin->decode (v16);
4479 if (size == 0)
4480 {
4481 size = PROFILE_BUFFER_CHUNK - span->offset % PROFILE_BUFFER_CHUNK;
4482 return size;
4483 }
4484 rcp = (Common_packet *) dwin->bind (span, size);
4485 }
4486 if (rcp == NULL)
4487 return 0;
4488
4489 if ((((long) rcp) % PACKET_ALIGNMENT) != 0)
4490 {
4491 invalid_packet++;
4492 size = PROFILE_BUFFER_CHUNK - span->offset % PROFILE_BUFFER_CHUNK;
4493 return size;
4494 }
4495 v16 = (uint16_t) rcp->type;
4496 uint32_t rcptype = dwin->decode (v16);
4497 if (rcptype == EMPTY_PCKT)
4498 return size;
4499 if (rcptype == FRAME_PCKT)
4500 {
4501 RawFramePacket *fp = new RawFramePacket;
4502 fp->uid = dwin->decode (((Frame_packet*) rcp)->uid);
4503 fp->uidn = NULL;
4504 fp->uidj = NULL;
4505 fp->omp_uid = NULL;
4506 fp->omp_state = 0;
4507 char *ptr = (char*) rcp + dwin->decode (((Frame_packet*) rcp)->hsize);
4508 if ((((long) ptr) % PACKET_ALIGNMENT) != 0)
4509 {
4510 invalid_packet++;
4511 delete fp;
4512 return size;
4513 }
4514 v16 = (uint16_t) ((Frame_packet*) rcp)->tsize;
4515 char *end = (char*) rcp + dwin->decode (v16);
4516 for (; ptr < end;)
4517 {
4518 Common_info *cinfo = (Common_info*) ptr;
4519 uint32_t hsize = dwin->decode (cinfo->hsize);
4520 if (hsize == 0 || ptr + hsize > end)
4521 break;
4522 int kind = dwin->decode (cinfo->kind);
4523 bool compressed = false;
4524 if (kind & COMPRESSED_INFO)
4525 {
4526 compressed = true;
4527 kind &= ~COMPRESSED_INFO;
4528 }
4529 switch (kind)
4530 {
4531 case STACK_INFO:
4532 {
4533 char *stack = ptr + sizeof (Stack_info);
4534 size_t stack_size = hsize - sizeof (Stack_info);
4535 uint64_t uidn = dwin->decode (((Stack_info*) cinfo)->uid);
4536 if (stack_size <= 0)
4537 {
4538 fp->uidn = get_uid_node (uidn);
4539 break;
4540 }
4541 uint64_t link_uid = (uint64_t) 0;
4542 if (compressed)
4543 {
4544 stack_size -= sizeof (uint64_t);
4545 unsigned char *s = (unsigned char*) (stack + stack_size);
4546 int shift = 0;
4547 for (size_t i = 0; i<sizeof (link_uid); i++)
4548 {
4549 link_uid |= (uint64_t) * s++ << shift;
4550 shift += 8;
4551 }
4552 }
4553 if (wsize == W32)
4554 fp->uidn = add_uid (dwin, uidn,
4555 (int) (stack_size / sizeof (uint32_t)),
4556 (uint32_t*) stack, link_uid);
4557 else
4558 fp->uidn = add_uid (dwin, uidn,
4559 (int) (stack_size / sizeof (uint64_t)),
4560 (uint64_t*) stack, link_uid);
4561 break;
4562 }
4563 case JAVA_INFO:
4564 {
4565 char *stack = ptr + sizeof (Java_info);
4566 size_t stack_size = hsize - sizeof (Java_info);
4567 uint64_t uidj = dwin->decode (((Java_info*) cinfo)->uid);
4568 if (stack_size <= 0)
4569 {
4570 fp->uidj = get_uid_node (uidj);
4571 break;
4572 }
4573
4574 uint64_t link_uid = (uint64_t) 0;
4575 if (compressed)
4576 {
4577 stack_size -= sizeof (uint64_t);
4578 unsigned char *s = (unsigned char*) (stack + stack_size);
4579 int shift = 0;
4580 for (size_t i = 0; i<sizeof (link_uid); i++)
4581 {
4582 link_uid |= (uint64_t) * s++ << shift;
4583 shift += 8;
4584 }
4585 }
4586 if (wsize == W32)
4587 fp->uidj = add_uid (dwin, uidj,
4588 (int) (stack_size / sizeof (uint32_t)),
4589 (uint32_t*) stack, link_uid);
4590 else
4591 {
4592 // bug 6909545: garbage in 64-bit JAVA_INFO
4593 char *nstack = (char*) malloc (stack_size);
4594 char *dst = nstack;
4595 char *srcmax = stack + stack_size - sizeof (uint64_t);
4596 for (char *src = stack; src <= srcmax;)
4597 {
4598 int64_t val = dwin->decode (*(int32_t*) src);
4599 *(uint64_t*) dst = dwin->decode (val);
4600 src += sizeof (uint64_t);
4601 dst += sizeof (uint64_t);
4602 if (src > srcmax)
4603 {
4604 fprintf (stderr, "er_print: Experiment::readPacket: Error in data: src=%llx greater than %llx\n",
4605 (long long) src, (long long) srcmax);
4606 break;
4607 }
4608 *(uint64_t*) dst = *(uint64_t*) src;
4609 src += sizeof (uint64_t);
4610 dst += sizeof (uint64_t);
4611 }
4612 fp->uidj = add_uid (dwin, uidj,
4613 (int) (stack_size / sizeof (uint64_t)),
4614 (uint64_t*) nstack, link_uid);
4615 free (nstack);
4616 }
4617 break;
4618 }
4619 case OMP_INFO:
4620 fp->omp_state = dwin->decode (((OMP_info*) ptr)->omp_state);
4621 break;
4622 case OMP2_INFO:
4623 {
4624 uint64_t omp_uid = dwin->decode (((OMP2_info*) ptr)->uid);
4625 fp->omp_uid = get_uid_node (omp_uid);
4626 fp->omp_state = dwin->decode (((OMP2_info*) ptr)->omp_state);
4627 break;
4628 }
4629 default:
4630 break;
4631 }
4632 ptr += hsize;
4633 }
4634 frmpckts->append (fp);
4635 return size;
4636 }
4637 else if (rcptype == UID_PCKT)
4638 {
4639 Uid_packet *uidp = (Uid_packet*) rcp;
4640 uint64_t uid = dwin->decode (uidp->uid);
4641 char *arr_bytes = (char*) (uidp + 1);
4642 v16 = (uint16_t) rcp->tsize;
4643 size_t arr_length = dwin->decode (v16) - sizeof (Uid_packet);
4644 if (arr_length <= 0)
4645 return size;
4646 uint64_t link_uid = (uint64_t) 0;
4647 if (dwin->decode (uidp->flags) & COMPRESSED_INFO)
4648 {
4649 arr_length -= sizeof (uint64_t);
4650 unsigned char *s = (unsigned char*) (arr_bytes + arr_length);
4651 int shift = 0;
4652 for (size_t i = 0; i<sizeof (link_uid); i++)
4653 {
4654 link_uid |= (uint64_t) * s++ << shift;
4655 shift += 8;
4656 }
4657 }
4658 if (wsize == W32)
4659 add_uid (dwin, uid, (int) (arr_length / sizeof (uint32_t)),
4660 (uint32_t*) arr_bytes, link_uid);
4661 else
4662 add_uid (dwin, uid, (int) (arr_length / sizeof (uint64_t)),
4663 (uint64_t*) arr_bytes, link_uid);
4664 return size;
4665 }
4666
4667 PacketDescriptor *pcktDescr = getPacketDescriptor (rcptype);
4668 if (pcktDescr == NULL)
4669 return size;
4670 DataDescriptor *dataDescr = pcktDescr->getDataDescriptor ();
4671 if (dataDescr == NULL)
4672 return size;
4673
4674 /* omazur: TBR START -- old experiment */
4675 if (rcptype == PROF_PCKT)
4676 {
4677 // For backward compatibility with older SS12 experiments
4678 int numstates = get_params ()->lms_magic_id; // ugly, for old experiments
4679 if (numstates > LMS_NUM_SOLARIS_MSTATES)
4680 numstates = LMS_NUM_SOLARIS_MSTATES;
4681 for (int i = 0; i < numstates; i++)
4682 if (check_mstate ((char*) rcp, pcktDescr, PROP_UCPU + i))
4683 readPacket (dwin, (char*) rcp, pcktDescr, dataDescr, PROP_UCPU + i,
4684 size);
4685 }
4686 else
4687 readPacket (dwin, (char*) rcp, pcktDescr, dataDescr, 0, size);
4688 return size;
4689 }
4690
4691 void
4692 Experiment::readPacket (Data_window *dwin, char *ptr, PacketDescriptor *pDscr,
4693 DataDescriptor *dDscr, int arg, uint64_t pktsz)
4694 {
4695 union Value
4696 {
4697 uint32_t val32;
4698 uint64_t val64;
4699 } *v;
4700
4701 long recn = dDscr->addRecord ();
4702 Vector<FieldDescr*> *fields = pDscr->getFields ();
4703 int sz = fields->size ();
4704 for (int i = 0; i < sz; i++)
4705 {
4706 FieldDescr *field = fields->fetch (i);
4707 v = (Value*) (ptr + field->offset);
4708 if (field->propID == arg)
4709 {
4710 dDscr->setValue (PROP_NTICK, recn, dwin->decode (v->val32));
4711 dDscr->setValue (PROP_MSTATE, recn, (uint32_t) (field->propID - PROP_UCPU));
4712 }
4713 if (field->propID == PROP_THRID || field->propID == PROP_LWPID
4714 || field->propID == PROP_CPUID)
4715 {
4716 uint64_t tmp64 = 0;
4717 switch (field->vtype)
4718 {
4719 case TYPE_INT32:
4720 case TYPE_UINT32:
4721 tmp64 = dwin->decode (v->val32);
4722 break;
4723 case TYPE_INT64:
4724 case TYPE_UINT64:
4725 tmp64 = dwin->decode (v->val64);
4726 break;
4727 case TYPE_STRING:
4728 case TYPE_DOUBLE:
4729 case TYPE_OBJ:
4730 case TYPE_DATE:
4731 case TYPE_BOOL:
4732 case TYPE_ENUM:
4733 case TYPE_LAST:
4734 case TYPE_NONE:
4735 break;
4736 }
4737 uint32_t tag = mapTagValue ((Prop_type) field->propID, tmp64);
4738 dDscr->setValue (field->propID, recn, tag);
4739 }
4740 else
4741 {
4742 switch (field->vtype)
4743 {
4744 case TYPE_INT32:
4745 case TYPE_UINT32:
4746 dDscr->setValue (field->propID, recn, dwin->decode (v->val32));
4747 break;
4748 case TYPE_INT64:
4749 case TYPE_UINT64:
4750 dDscr->setValue (field->propID, recn, dwin->decode (v->val64));
4751 break;
4752 case TYPE_STRING:
4753 {
4754 int len = (int) (pktsz - field->offset);
4755 if ((len > 0) && (ptr[field->offset] != 0))
4756 {
4757 StringBuilder *sb = new StringBuilder ();
4758 sb->append (ptr + field->offset, 0, len);
4759 dDscr->setObjValue (field->propID, recn, sb);
4760 }
4761 break;
4762 }
4763 // ignoring the following cases (why?)
4764 case TYPE_DOUBLE:
4765 case TYPE_OBJ:
4766 case TYPE_DATE:
4767 case TYPE_BOOL:
4768 case TYPE_ENUM:
4769 case TYPE_LAST:
4770 case TYPE_NONE:
4771 break;
4772 }
4773 }
4774 }
4775 }
4776
4777 #define PROG_BYTE 102400 // update progress bar every PROG_BYTE bytes
4778
4779 void
4780 Experiment::read_data_file (const char *fname, const char *msg)
4781 {
4782 Data_window::Span span;
4783 off64_t total_len, remain_len;
4784 char *progress_bar_msg;
4785 int progress_bar_percent = -1;
4786
4787 char *data_file_name = dbe_sprintf (NTXT ("%s/%s"), expt_name, fname);
4788 Data_window *dwin = new Data_window (data_file_name);
4789 // Here we can call stat(data_file_name) to get file size,
4790 // and call a function to reallocate vectors for clock profiling data
4791 free (data_file_name);
4792 if (dwin->not_opened ())
4793 {
4794 delete dwin;
4795 return;
4796 }
4797 dwin->need_swap_endian = need_swap_endian;
4798
4799 span.offset = 0;
4800 span.length = dwin->get_fsize ();
4801 total_len = remain_len = span.length;
4802 progress_bar_msg = dbe_sprintf (NTXT ("%s %s"), NTXT (" "), msg);
4803 invalid_packet = 0;
4804 for (;;)
4805 {
4806 uint64_t pcktsz = readPacket (dwin, &span);
4807 if (pcktsz == 0)
4808 break;
4809 // Update progress bar
4810 if ((span.length <= remain_len) && (remain_len > 0))
4811 {
4812 int percent = (int) (100 * (total_len - remain_len) / total_len);
4813 if (percent > progress_bar_percent)
4814 {
4815 progress_bar_percent += 10;
4816 theApplication->set_progress (percent, progress_bar_msg);
4817 }
4818 remain_len -= PROG_BYTE;
4819 }
4820 span.length -= pcktsz;
4821 span.offset += pcktsz;
4822 }
4823 delete dwin;
4824
4825 if (invalid_packet)
4826 {
4827 StringBuilder sb;
4828 sb.sprintf (GTXT ("WARNING: There are %d invalid packet(s) in the %s file"),
4829 invalid_packet, fname);
4830 Emsg *m = new Emsg (CMSG_WARN, sb);
4831 warnq->append (m);
4832 }
4833
4834 theApplication->set_progress (0, NTXT (""));
4835 free (progress_bar_msg);
4836 }
4837
4838 int
4839 Experiment::read_overview_file ()
4840 {
4841 char *data_file_name = dbe_sprintf ("%s/%s", expt_name, SP_OVERVIEW_FILE);
4842 Data_window *dwin = new Data_window (data_file_name);
4843 free (data_file_name);
4844 if (dwin->not_opened ())
4845 {
4846 delete dwin;
4847 return 0;
4848 }
4849 dwin->need_swap_endian = need_swap_endian;
4850 newDataDescriptor (DATA_SAMPLE);
4851
4852 Data_window::Span span;
4853 span.offset = 0;
4854 span.length = dwin->get_fsize ();
4855
4856 PrUsage *data = NULL, *data_prev = NULL;
4857 Sample *sample;
4858 int sample_number = 1;
4859
4860 int64_t prDataSize;
4861 if (wsize == W32)
4862 prDataSize = PrUsage::bind32Size ();
4863 else
4864 prDataSize = PrUsage::bind64Size ();
4865
4866 while (span.length > 0)
4867 {
4868 data_prev = data;
4869 data = new PrUsage ();
4870
4871 void *dw = dwin->bind (&span, prDataSize);
4872 if ((dw == NULL) || (prDataSize > span.length))
4873 {
4874 Emsg *m = new Emsg (CMSG_ERROR, GTXT ("Warning: overview data file can't be read"));
4875 warnq->append (m);
4876 status = FAILURE;
4877 delete dwin;
4878 return status;
4879 }
4880
4881 if (wsize == W32)
4882 data->bind32 (dw, need_swap_endian);
4883 else
4884 data->bind64 (dw, need_swap_endian);
4885 span.length -= prDataSize;
4886 span.offset += prDataSize;
4887
4888 // Skip the first packet
4889 if (data_prev == NULL)
4890 continue;
4891 if (sample_number > samples->size ())
4892 { // inconsistent log/overview
4893 sample = new Sample (sample_number);
4894 char * label = GTXT ("<unknown>");
4895 sample->start_label = dbe_strdup (label);
4896 sample->end_label = dbe_strdup (label);
4897 samples->append (sample);
4898 }
4899 else
4900 sample = samples->fetch (sample_number - 1);
4901 sample_number++;
4902 sample->start_time = data_prev->pr_tstamp + 1;
4903 sample->end_time = data->pr_tstamp;
4904 sample->prusage = data_prev;
4905
4906 data_prev->pr_rtime = data->pr_rtime - data_prev->pr_rtime;
4907 data_prev->pr_utime = data->pr_utime - data_prev->pr_utime;
4908 data_prev->pr_stime = data->pr_stime - data_prev->pr_stime;
4909 data_prev->pr_ttime = data->pr_ttime - data_prev->pr_ttime;
4910 data_prev->pr_tftime = data->pr_tftime - data_prev->pr_tftime;
4911 data_prev->pr_dftime = data->pr_dftime - data_prev->pr_dftime;
4912 data_prev->pr_kftime = data->pr_kftime - data_prev->pr_kftime;
4913 data_prev->pr_ltime = data->pr_ltime - data_prev->pr_ltime;
4914 data_prev->pr_slptime = data->pr_slptime - data_prev->pr_slptime;
4915 data_prev->pr_wtime = data->pr_wtime - data_prev->pr_wtime;
4916 data_prev->pr_stoptime = data->pr_stoptime - data_prev->pr_stoptime;
4917 data_prev->pr_minf = data->pr_minf - data_prev->pr_minf;
4918 data_prev->pr_majf = data->pr_majf - data_prev->pr_majf;
4919 data_prev->pr_nswap = data->pr_nswap - data_prev->pr_nswap;
4920 data_prev->pr_inblk = data->pr_inblk - data_prev->pr_inblk;
4921 data_prev->pr_oublk = data->pr_oublk - data_prev->pr_oublk;
4922 data_prev->pr_msnd = data->pr_msnd - data_prev->pr_msnd;
4923 data_prev->pr_mrcv = data->pr_mrcv - data_prev->pr_mrcv;
4924 data_prev->pr_sigs = data->pr_sigs - data_prev->pr_sigs;
4925 data_prev->pr_vctx = data->pr_vctx - data_prev->pr_vctx;
4926 data_prev->pr_ictx = data->pr_ictx - data_prev->pr_ictx;
4927 data_prev->pr_sysc = data->pr_sysc - data_prev->pr_sysc;
4928 data_prev->pr_ioch = data->pr_ioch - data_prev->pr_ioch;
4929 sample->get_usage (); // force validation
4930 }
4931
4932 for (long smpNum = samples->size (); smpNum >= sample_number; smpNum--)
4933 {
4934 // overview file was truncated
4935 sample = samples->remove (smpNum - 1);
4936 delete sample;
4937 }
4938
4939 if (data)
4940 {
4941 // Update last_event so that getEndTime() covers
4942 // all loadobjects, too.
4943 update_last_event (data->pr_tstamp);
4944 delete data;
4945 }
4946 delete dwin;
4947 return SUCCESS;
4948 }
4949
4950 int
4951 Experiment::uidNodeCmp (const void *a, const void *b)
4952 {
4953 UIDnode *nd1 = *(UIDnode**) a;
4954 UIDnode *nd2 = *(UIDnode**) b;
4955 if (nd1->uid == nd2->uid)
4956 return 0;
4957 return nd1->uid < nd2->uid ? -1 : 1;
4958 }
4959
4960 static uint64_t
4961 funcAddr (uint32_t val)
4962 {
4963 if (val == (uint32_t) SP_LEAF_CHECK_MARKER)
4964 return (uint64_t) SP_LEAF_CHECK_MARKER;
4965 if (val == (uint32_t) SP_TRUNC_STACK_MARKER)
4966 return (uint64_t) SP_TRUNC_STACK_MARKER;
4967 if (val == (uint32_t) SP_FAILED_UNWIND_MARKER)
4968 return (uint64_t) SP_FAILED_UNWIND_MARKER;
4969 return val;
4970 }
4971
4972 Experiment::UIDnode *
4973 Experiment::add_uid (Data_window *dwin, uint64_t uid, int size,
4974 uint32_t *array, uint64_t link_uid)
4975 {
4976 if (uid == (uint64_t) 0)
4977 return NULL;
4978 uint64_t val = funcAddr (dwin->decode (array[0]));
4979 UIDnode *node = NULL;
4980 UIDnode *res = get_uid_node (uid, val);
4981 UIDnode *next = res;
4982 for (int i = 0; i < size; i++)
4983 {
4984 val = funcAddr (dwin->decode (array[i]));
4985 if (next == NULL)
4986 {
4987 next = get_uid_node ((uint64_t) 0, val);
4988 if (node != NULL)
4989 node->next = next;
4990 }
4991 node = next;
4992 next = node->next;
4993 if (node->val == 0)
4994 node->val = val;
4995 else if (node->val != val) // Algorithmic error (should never happen)
4996 node->val = (uint64_t) SP_LEAF_CHECK_MARKER;
4997 }
4998 if (next == NULL && link_uid != (uint64_t) 0 && node != NULL)
4999 node->next = get_uid_node (link_uid);
5000 return res;
5001 }
5002
5003 Experiment::UIDnode *
5004 Experiment::add_uid (Data_window *dwin, uint64_t uid, int size, uint64_t *array, uint64_t link_uid)
5005 {
5006 if (uid == (uint64_t) 0)
5007 return NULL;
5008 UIDnode *node = NULL;
5009 uint64_t val = dwin->decode (array[0]);
5010 UIDnode *res = get_uid_node (uid, val);
5011 UIDnode *next = res;
5012 for (int i = 0; i < size; i++)
5013 {
5014 val = dwin->decode (array[i]);
5015 if (next == NULL)
5016 {
5017 next = get_uid_node ((uint64_t) 0, val);
5018 if (node != NULL)
5019 node->next = next;
5020 }
5021 node = next;
5022 next = node->next;
5023 if (node->val == (uint64_t) 0)
5024 node->val = val;
5025 else if (node->val != val) // Algorithmic error (should never happen)
5026 node->val = (uint64_t) - 1;
5027 }
5028 if (next == NULL && link_uid != (uint64_t) 0 && node != NULL)
5029 node->next = get_uid_node (link_uid);
5030 return res;
5031 }
5032
5033 Experiment::UIDnode *
5034 Experiment::new_uid_node (uint64_t uid, uint64_t val)
5035 {
5036 #define NCHUNKSTEP 1024
5037 if (nnodes >= nchunks * CHUNKSZ)
5038 {
5039 // Reallocate Node chunk array
5040 UIDnode** old_chunks = chunks;
5041 chunks = new UIDnode*[nchunks + NCHUNKSTEP];
5042 memcpy (chunks, old_chunks, nchunks * sizeof (UIDnode*));
5043 nchunks += NCHUNKSTEP;
5044 delete[] old_chunks;
5045 // Clean future pointers
5046 memset (&chunks[nchunks - NCHUNKSTEP], 0, NCHUNKSTEP * sizeof (UIDnode*));
5047 }
5048
5049 if (NULL == chunks[nnodes / CHUNKSZ]) // Allocate new chunk for nodes.
5050 chunks[nnodes / CHUNKSZ] = new UIDnode[CHUNKSZ];
5051 UIDnode *node = &chunks[nnodes / CHUNKSZ][nnodes % CHUNKSZ];
5052 node->uid = uid;
5053 node->val = val;
5054 node->next = NULL;
5055 nnodes++;
5056 return node;
5057 }
5058
5059 Experiment::UIDnode *
5060 Experiment::get_uid_node (uint64_t uid, uint64_t val)
5061 {
5062 int hash = (((int) uid) >> 4) & (HTableSize - 1);
5063 if (uid != (uint64_t) 0)
5064 {
5065 UIDnode *node = uidHTable[hash];
5066 if (node && node->uid == uid)
5067 return node;
5068 }
5069 UIDnode *node = new_uid_node (uid, val);
5070 if (uid != (uint64_t) 0)
5071 {
5072 uidHTable[hash] = node;
5073 uidnodes->append (node);
5074 }
5075 return node;
5076 }
5077
5078 Experiment::UIDnode *
5079 Experiment::get_uid_node (uint64_t uid)
5080 {
5081 if (uid == (uint64_t) 0)
5082 return NULL;
5083 int hash = (((int) uid) >> 4) & (HTableSize - 1);
5084 UIDnode *node = uidHTable[hash];
5085 if (node && node->uid == uid)
5086 return node;
5087 node = new_uid_node (uid, (uint64_t) 0);
5088 node->next = node;
5089 return node;
5090 }
5091
5092 Experiment::UIDnode *
5093 Experiment::find_uid_node (uint64_t uid)
5094 {
5095 int hash = (((int) uid) >> 4) & (HTableSize - 1);
5096 UIDnode *node = uidHTable[hash];
5097 if (node && node->uid == uid)
5098 return node;
5099 int lt = 0;
5100 int rt = uidnodes->size () - 1;
5101 while (lt <= rt)
5102 {
5103 int md = (lt + rt) / 2;
5104 node = uidnodes->fetch (md);
5105 if (node->uid < uid)
5106 lt = md + 1;
5107 else if (node->uid > uid)
5108 rt = md - 1;
5109 else
5110 {
5111 uidHTable[hash] = node;
5112 return node;
5113 }
5114 }
5115 return NULL;
5116 }
5117
5118 int
5119 Experiment::frUidCmp (const void *a, const void *b)
5120 {
5121 RawFramePacket *fp1 = *(RawFramePacket**) a;
5122 RawFramePacket *fp2 = *(RawFramePacket**) b;
5123 if (fp1->uid == fp2->uid)
5124 return 0;
5125 return fp1->uid < fp2->uid ? -1 : 1;
5126 }
5127
5128 Experiment::RawFramePacket *
5129 Experiment::find_frame_packet (uint64_t uid)
5130 {
5131 int lt = 0;
5132 int rt = frmpckts->size () - 1;
5133 while (lt <= rt)
5134 {
5135 int md = (lt + rt) / 2;
5136 RawFramePacket *fp = frmpckts->fetch (md);
5137 if (fp->uid < uid)
5138 lt = md + 1;
5139 else if (fp->uid > uid)
5140 rt = md - 1;
5141 else
5142 return fp;
5143 }
5144
5145 return NULL;
5146 }
5147
5148 #define FRINFO_CACHEOPT_SIZE_LIMIT 4000000
5149 #define FRINFO_PIPELINE_SIZE_LIMIT 500000
5150 #define FRINFO_PIPELINE_NUM_STAGES 3
5151
5152 // Pipelined execution of resolve_frame_info() and add_stack().
5153 // Since this is the largest time consuming part of loading an experiment (especially
5154 // so for large java experiments) - executing this part as a 3 stage pipeline can
5155 // give significant performance gain - and this concept can be aggressively applied
5156 // to enhance the gain further in future. The three stages are:
5157 // Phase 1: resolve_frame_info()
5158 // Phase 2: first part of add_stack() where the native stack is built
5159 // Phase 3: second part og add_stack() where the java stack is built
5160 // Phase 4: insert the native and java stacks into the stack map
5161 // The main thread operates in the first Phase and the other stages are
5162 // operated by a ssplib sequential queue - The threads working on the queues run concurrently
5163 // with each other and with the main thread. But within a particular queue, jobs are
5164 // executed sequentially
5165
5166
5167 // This is the second phase of the pipeline of resolve_frame_info and add_stack
5168 // It works on a chunk of iterations (size CSTCTX_CHUNK_SZ) and invokes add_stack()
5169 // for each one of them
5170
5171 void
5172 Experiment::resolve_frame_info (DataDescriptor *dDscr)
5173 {
5174 if (!resolveFrameInfo)
5175 return;
5176 if (NULL == cstack)
5177 return;
5178 dDscr->setResolveFrInfoDone ();
5179
5180 // Check for TSTAMP
5181 int propID = dbeSession->getPropIdByName (NTXT ("TSTAMP"));
5182 Data *dataTStamp = dDscr->getData (propID);
5183 if (dataTStamp == NULL)
5184 return;
5185
5186 propID = dbeSession->getPropIdByName (NTXT ("FRINFO"));
5187 Data *dataFrinfo = dDscr->getData (propID);
5188
5189 propID = dbeSession->getPropIdByName (NTXT ("THRID"));
5190 Data *dataThrId = dDscr->getData (propID);
5191
5192 // We can get frame info either by FRINFO or by [THRID,STKIDX]
5193 if (dataFrinfo == NULL)
5194 return;
5195
5196 char *propName = NTXT ("MSTACK");
5197 propID = dbeSession->getPropIdByName (propName);
5198 PropDescr *prMStack = new PropDescr (propID, propName);
5199 prMStack->uname = dbe_strdup (GTXT ("Machine Call Stack"));
5200 prMStack->vtype = TYPE_OBJ;
5201 dDscr->addProperty (prMStack);
5202
5203 propName = NTXT ("USTACK");
5204 propID = dbeSession->getPropIdByName (propName);
5205 PropDescr *prUStack = new PropDescr (propID, propName);
5206 prUStack->uname = dbe_strdup (GTXT ("User Call Stack"));
5207 prUStack->vtype = TYPE_OBJ;
5208 dDscr->addProperty (prUStack);
5209
5210 propName = NTXT ("XSTACK");
5211 propID = dbeSession->getPropIdByName (propName);
5212 PropDescr *prXStack = new PropDescr (propID, propName);
5213 prXStack->uname = dbe_strdup (GTXT ("Expert Call Stack"));
5214 prXStack->vtype = TYPE_OBJ;
5215 dDscr->addProperty (prXStack);
5216
5217 propName = NTXT ("HSTACK");
5218 propID = dbeSession->getPropIdByName (propName);
5219 PropDescr *prHStack = new PropDescr (propID, propName);
5220 prHStack->uname = dbe_strdup (GTXT ("ShowHide Call Stack"));
5221 prHStack->vtype = TYPE_OBJ;
5222 dDscr->addProperty (prHStack);
5223
5224 if (has_java)
5225 {
5226 propName = NTXT ("JTHREAD");
5227 propID = dbeSession->getPropIdByName (propName);
5228 PropDescr *prJThread = new PropDescr (propID, propName);
5229 prJThread->uname = dbe_strdup (GTXT ("Java Thread"));
5230 prJThread->vtype = TYPE_OBJ;
5231 dDscr->addProperty (prJThread);
5232 }
5233
5234 if (ompavail)
5235 {
5236 PropDescr *prop = new PropDescr (PROP_OMPSTATE, NTXT ("OMPSTATE"));
5237 prop->uname = dbe_strdup (GTXT ("OpenMP state"));
5238 prop->vtype = TYPE_UINT32;
5239 char * stateNames [OMP_LAST_STATE] = OMP_THR_STATE_STRINGS;
5240 char * stateUNames[OMP_LAST_STATE] = OMP_THR_STATE_USTRINGS;
5241 for (int ii = 0; ii < OMP_LAST_STATE; ii++)
5242 prop->addState (ii, stateNames[ii], stateUNames[ii]);
5243 dDscr->addProperty (prop);
5244
5245 // add PROP_CPRID to profiling data (not same as omptrace's PROP_CPRID)
5246 prop = dDscr->getProp (PROP_CPRID);
5247 if (prop)
5248 {
5249 VType_type type = prop->vtype;
5250 assert (type == TYPE_OBJ); //see 7040526
5251 }
5252 prop = new PropDescr (PROP_CPRID, NTXT ("CPRID")); //profiling PROP_CPRID
5253 prop->uname = dbe_strdup (GTXT ("OpenMP parallel region"));
5254 prop->vtype = TYPE_OBJ;
5255 dDscr->addProperty (prop);
5256
5257 // add PROP_TSKID to profiling data (not same as omptrace's PROP_TSKID)
5258 prop = dDscr->getProp (PROP_TSKID);
5259 if (prop)
5260 {
5261 VType_type type = prop->vtype;
5262 assert (type == TYPE_OBJ); //see 7040526
5263 }
5264 prop = new PropDescr (PROP_TSKID, NTXT ("TSKID")); //profiling PROP_TSKID
5265 prop->uname = dbe_strdup (GTXT ("OpenMP task"));
5266 prop->vtype = TYPE_OBJ;
5267 dDscr->addProperty (prop);
5268 }
5269 char *progress_bar_msg = dbe_sprintf (NTXT ("%s %s: %s"), NTXT (" "),
5270 GTXT ("Processing CallStack Data"),
5271 get_basename (expt_name));
5272 int progress_bar_percent = -1;
5273 long deltaReport = 5000;
5274 long nextReport = 0;
5275
5276 long size = dDscr->getSize ();
5277 // bool resolve_frinfo_pipelined = size > FRINFO_PIPELINE_SIZE_LIMIT && !ompavail;
5278 bool resolve_frinfo_pipelined = false;
5279
5280 Map<uint64_t, uint64_t> *nodeCache = NULL;
5281 Map<uint64_t, uint64_t> *frameInfoCache = NULL;
5282 if (size > FRINFO_CACHEOPT_SIZE_LIMIT && dversion == NULL)
5283 {
5284 frameInfoCache = new CacheMap<uint64_t, uint64_t>;
5285 nodeCache = new CacheMap<uint64_t, uint64_t>;
5286 }
5287
5288 pushCnt = popCnt = pushCnt3 = popCnt3 = 0;
5289 nPush = nPop = 0;
5290
5291 FramePacket *fp = NULL;
5292 // DbeThreadPool * threadPool = new DbeThreadPool(5);
5293 fp = new FramePacket;
5294 fp->stack = new Vector<Vaddr>;
5295 fp->jstack = new Vector<Vaddr>;
5296 fp->ompstack = new Vector<Vaddr>;
5297 fp->omp_state = 0;
5298 fp->mpi_state = 0;
5299
5300 // piggyback on post-processing to calculate exp->last_event
5301 const hrtime_t _exp_start_time = getStartTime (); // wall clock time
5302 hrtime_t exp_duration = getLastEvent () == ZERO_TIME ? 0
5303 : getLastEvent () - _exp_start_time; // zero-based
5304
5305 int missed_fi = 0;
5306 int total_fi = 0;
5307
5308 for (long i = 0; i < size; i++)
5309 {
5310 if (i == nextReport)
5311 {
5312 int percent = (int) (i * 100 / size);
5313 if (percent > progress_bar_percent)
5314 {
5315 progress_bar_percent += 10;
5316 theApplication->set_progress (percent, progress_bar_msg);
5317 }
5318 nextReport += deltaReport;
5319 }
5320
5321 uint32_t thrid = (uint32_t) dataThrId->fetchInt (i);
5322 hrtime_t tstamp = (hrtime_t) dataTStamp->fetchLong (i);
5323
5324 // piggyback on post-processing to calculate exp->last_event
5325 {
5326 hrtime_t relative_timestamp = tstamp - _exp_start_time;
5327 if (exp_duration < relative_timestamp)
5328 exp_duration = relative_timestamp;
5329 }
5330 uint64_t frinfo = (uint64_t) dataFrinfo->fetchLong (i);
5331
5332 RawFramePacket *rfp = NULL;
5333 if (frinfo)
5334 {
5335 // CacheMap does not work with NULL key
5336 if (frameInfoCache != NULL)
5337 rfp = (RawFramePacket *) frameInfoCache->get (frinfo);
5338 }
5339 if (rfp == 0)
5340 {
5341 rfp = find_frame_packet (frinfo);
5342 if (rfp != 0)
5343 {
5344 if (frameInfoCache != NULL)
5345 frameInfoCache->put (frinfo, (uint64_t) rfp);
5346 }
5347 else
5348 missed_fi++;
5349 total_fi++;
5350 }
5351
5352 // Process OpenMP properties
5353 if (ompavail)
5354 {
5355 fp->omp_state = rfp ? rfp->omp_state : 0;
5356 dDscr->setValue (PROP_OMPSTATE, i, fp->omp_state);
5357
5358 fp->omp_cprid = mapPRid->get (thrid, tstamp, mapPRid->REL_EQLE);
5359 void *omp_preg = mapPReg->get (thrid, tstamp, mapPReg->REL_EQLE);
5360 if (!omp_preg)
5361 {
5362 char *idxname = NTXT ("OMP_preg");
5363 int idxtype = dbeSession->findIndexSpaceByName (idxname);
5364 if (idxtype != -1)
5365 {
5366 Histable *preg0 = dbeSession->findObjectById (Histable::INDEXOBJ, idxtype, (int64_t) 0);
5367 if (preg0)
5368 {
5369 Vector<Histable*> pregs;
5370 pregs.append (preg0);
5371 omp_preg = cstack->add_stack (&pregs);
5372 mapPReg->put (thrid, tstamp, omp_preg);
5373 }
5374 }
5375 }
5376 dDscr->setObjValue (PROP_CPRID, i, omp_preg); //profiling PROP_CPRID
5377 void *omp_task = mapTask->get (thrid, tstamp, mapTask->REL_EQLE);
5378 if (!omp_task)
5379 {
5380 char *idxname = NTXT ("OMP_task");
5381 int idxtype = dbeSession->findIndexSpaceByName (idxname);
5382 if (idxtype != -1)
5383 {
5384 Histable *task0 = dbeSession->findObjectById (Histable::INDEXOBJ, idxtype, (int64_t) 0);
5385 if (task0)
5386 {
5387 Vector<Histable*> tasks;
5388 tasks.append (task0);
5389 omp_task = cstack->add_stack (&tasks);
5390 mapTask->put (thrid, tstamp, omp_task);
5391 }
5392 }
5393 }
5394 dDscr->setObjValue (PROP_TSKID, i, omp_task); //profiling PROP_TSKID
5395 }
5396 else
5397 {
5398 fp->omp_state = 0;
5399 fp->omp_cprid = 0;
5400 }
5401
5402 // Construct the native stack
5403 fp->stack->reset ();
5404 Vaddr leafpc = dDscr->getULongValue (PROP_LEAFPC, i);
5405 if (leafpc)
5406 fp->stack->append (leafpc);
5407 UIDnode *node = rfp ? rfp->uidn : NULL;
5408 while (node)
5409 {
5410 if (node->next == node)
5411 // this node contains link_uid
5412 node = find_uid_node (node->uid);
5413 else
5414 {
5415 fp->stack->append (node->val);
5416 node = node->next;
5417 }
5418 }
5419 fp->truncated = 0;
5420 int last = fp->stack->size () - 1;
5421 if (last >= 0)
5422 {
5423 switch (fp->stack->fetch (last))
5424 {
5425 case SP_TRUNC_STACK_MARKER:
5426 fp->truncated = (Vaddr) SP_TRUNC_STACK_MARKER;
5427 fp->stack->remove (last);
5428 break;
5429 case SP_FAILED_UNWIND_MARKER:
5430 fp->truncated = (Vaddr) SP_FAILED_UNWIND_MARKER;
5431 fp->stack->remove (last);
5432 break;
5433 }
5434 }
5435
5436 // Construct the Java stack
5437 fp->jstack->reset ();
5438 node = rfp ? rfp->uidj : NULL;
5439 while (node)
5440 {
5441 if (node->next == node)
5442 {
5443 // this node contains link_uid
5444 UIDnode *n = NULL;
5445 if (node->uid)
5446 {
5447 // CacheMap does not work with NULL key
5448 if (nodeCache != NULL)
5449 n = (UIDnode *) nodeCache->get (node->uid);
5450 }
5451 if (n == NULL)
5452 {
5453 n = find_uid_node (node->uid);
5454 if (n != NULL)
5455 {
5456 if (nodeCache != NULL)
5457 nodeCache->put (node->uid, (uint64_t) n);
5458 }
5459 }
5460 node = n;
5461 }
5462 else
5463 {
5464 fp->jstack->append (node->val);
5465 node = node->next;
5466 }
5467 }
5468 fp->jtruncated = false;
5469 last = fp->jstack->size () - 1;
5470 if (last >= 1 && fp->jstack->fetch (last) == SP_TRUNC_STACK_MARKER)
5471 {
5472 fp->jtruncated = true;
5473 fp->jstack->remove (last);
5474 fp->jstack->remove (last - 1);
5475 }
5476
5477 // Construct the OpenMP stack
5478 if (ompavail)
5479 {
5480 fp->ompstack->reset ();
5481 if (rfp && rfp->omp_uid)
5482 {
5483 if (leafpc)
5484 fp->ompstack->append (leafpc);
5485 node = rfp->omp_uid;
5486 while (node)
5487 {
5488 if (node->next == node)
5489 // this node contains link_uid
5490 node = find_uid_node (node->uid);
5491 else
5492 {
5493 fp->ompstack->append (node->val);
5494 node = node->next;
5495 }
5496 }
5497 fp->omptruncated = false;
5498 last = fp->ompstack->size () - 1;
5499 if (last >= 0)
5500 {
5501 switch (fp->ompstack->fetch (last))
5502 {
5503 case SP_TRUNC_STACK_MARKER:
5504 fp->omptruncated = (Vaddr) SP_TRUNC_STACK_MARKER;
5505 fp->ompstack->remove (last);
5506 break;
5507 case SP_FAILED_UNWIND_MARKER:
5508 fp->omptruncated = (Vaddr) SP_FAILED_UNWIND_MARKER;
5509 fp->ompstack->remove (last);
5510 break;
5511 }
5512 }
5513 }
5514 }
5515 cstack->add_stack (dDscr, i, fp, NULL);
5516 }
5517
5518 // piggyback on post-processing to calculate exp->last_event
5519 {
5520 hrtime_t exp_end_time = _exp_start_time + exp_duration;
5521 update_last_event (exp_end_time);
5522 }
5523
5524 if (missed_fi > 0)
5525 {
5526 StringBuilder sb;
5527 sb.sprintf (
5528 GTXT ("*** Warning: %d frameinfo packets are missing from total of %d when resolving %s."),
5529 missed_fi, total_fi, dDscr->getName ());
5530 warnq->append (new Emsg (CMSG_WARN, sb));
5531 }
5532
5533 // threadPool->wait_group();
5534 // delete threadPool;
5535 theApplication->set_progress (0, NTXT (""));
5536 free (progress_bar_msg);
5537 if (!resolve_frinfo_pipelined && fp != NULL)
5538 {
5539 delete fp->ompstack;
5540 delete fp->jstack;
5541 delete fp->stack;
5542 delete fp;
5543 }
5544 delete frameInfoCache;
5545 frameInfoCache = NULL;
5546 delete nodeCache;
5547 nodeCache = NULL;
5548 }
5549
5550 void
5551 Experiment::post_process ()
5552 {
5553 // update non_paused_time after final update to "last_event"
5554 if (resume_ts != MAX_TIME && last_event)
5555 {
5556 hrtime_t ts = last_event - exp_start_time;
5557 hrtime_t delta = ts - resume_ts;
5558 non_paused_time += delta;
5559 resume_ts = MAX_TIME; // collection is paused
5560 }
5561
5562 // GC: prune events outside of experiment duration, calculate GC duration, update indices
5563 int index;
5564 GCEvent * gcevent;
5565 gc_duration = ZERO_TIME;
5566 if (gcevents != NULL)
5567 {
5568 // delete events that finish before exp_start_time or start after last_event
5569 for (int ii = 0; ii < gcevents->size ();)
5570 {
5571 gcevent = gcevents->fetch (ii);
5572 if (gcevent->end - exp_start_time < 0
5573 || last_event - gcevent->start < 0)
5574 delete gcevents->remove (ii);
5575 else
5576 ii++;
5577 }
5578 }
5579 Vec_loop (GCEvent*, gcevents, index, gcevent)
5580 {
5581 gcevent->id = index + 1; // renumber to account for any deleted events
5582 if (gcevent->start - exp_start_time < 0 || gcevent->start == ZERO_TIME)
5583 // truncate events that start before experiment start
5584 gcevent->start = exp_start_time;
5585 if (last_event - gcevent->end < 0)
5586 // truncate events that end after experiment end
5587 gcevent->end = last_event;
5588 gc_duration += gcevent->end - gcevent->start;
5589 }
5590 }
5591
5592 Experiment::Exp_status
5593 Experiment::find_expdir (char *path)
5594 {
5595 // This function checks that the experiment directory
5596 // is of the proper form, and accessible
5597 dbe_stat_t sbuf;
5598
5599 // Save the name
5600 expt_name = dbe_strdup (path);
5601
5602 // Check that the name ends in .er
5603 size_t i = strlen (path);
5604 if (i > 0 && path[i - 1] == '/')
5605 path[--i] = '\0';
5606
5607 if (i < 4 || strcmp (&path[i - 3], NTXT (".er")) != 0)
5608 {
5609 Emsg *m = new Emsg (CMSG_FATAL,
5610 GTXT ("*** Error: not a valid experiment name"));
5611 errorq->append (m);
5612 status = FAILURE;
5613 return FAILURE;
5614 }
5615
5616 // Check if new directory structure (i.e., no pointer file)
5617 if (dbe_stat (path, &sbuf))
5618 {
5619 Emsg *m = new Emsg (CMSG_FATAL, GTXT ("*** Error: experiment not found"));
5620 errorq->append (m);
5621 status = FAILURE;
5622 return FAILURE;
5623 }
5624 if (S_ISDIR (sbuf.st_mode) == 0)
5625 {
5626 // ignore pointer-file experiments
5627 Emsg *m = new Emsg (CMSG_FATAL,
5628 GTXT ("*** Error: experiment was recorded with an earlier version, and can not be read"));
5629 errorq->append (m);
5630 obsolete = 1;
5631 status = FAILURE;
5632 return FAILURE;
5633 }
5634 return SUCCESS;
5635 }
5636
5637 void
5638 Experiment::purge ()
5639 {
5640 // This routine will purge all of the caches of releasable storage.
5641 for (int i = 0; i < dataDscrs->size (); ++i)
5642 {
5643 DataDescriptor *dataDscr = dataDscrs->fetch (i);
5644 if (dataDscr == NULL)
5645 continue;
5646 dataDscr->reset ();
5647 }
5648 delete cstack;
5649 delete cstackShowHide;
5650 cstack = CallStack::getInstance (this);
5651 cstackShowHide = CallStack::getInstance (this);
5652 }
5653
5654 void
5655 Experiment::resetShowHideStack ()
5656 {
5657 delete cstackShowHide;
5658 cstackShowHide = CallStack::getInstance (this);
5659 }
5660
5661 #define GET_INT_VAL(v, s, len) \
5662 for (v = len = 0; isdigit(*s); s++, len++) { v = v * 10 + (*s -'0'); }
5663
5664 static int
5665 dir_name_cmp (const void *a, const void *b)
5666 {
5667 char *s1 = *((char **) a);
5668 char *s2 = *((char **) b);
5669 while (*s1)
5670 {
5671 if (isdigit (*s1) && isdigit (*s2))
5672 {
5673 int v1, v2, len1, len2;
5674 GET_INT_VAL (v1, s1, len1);
5675 GET_INT_VAL (v2, s2, len2);
5676 if (v1 != v2)
5677 return v1 - v2;
5678 if (len1 != len2)
5679 return len2 - len1;
5680 continue;
5681 }
5682 if (*s1 != *s2)
5683 break;
5684 s1++;
5685 s2++;
5686 }
5687 return *s1 - *s2;
5688 }
5689
5690 Vector<char*> *
5691 Experiment::get_descendants_names ()
5692 {
5693 char *dir_name = get_expt_name ();
5694 if (dir_name == NULL)
5695 return NULL;
5696 DIR *exp_dir = opendir (dir_name);
5697 if (exp_dir == NULL)
5698 return NULL;
5699 Vector<char*> *exp_names = new Vector<char*>();
5700 for (struct dirent *entry = readdir (exp_dir); entry;
5701 entry = readdir (exp_dir))
5702 {
5703 if (entry->d_name[0] == '_' || strncmp (entry->d_name, "M_r", 3) == 0)
5704 {
5705 char *dpath = dbe_sprintf (NTXT ("%s/%s"), dir_name, entry->d_name);
5706 dbe_stat_t sbuf;
5707 if (dbe_stat (dpath, &sbuf) == 0 && S_ISDIR (sbuf.st_mode))
5708 exp_names->append (dpath);
5709 else
5710 free (dpath);
5711 }
5712 }
5713 closedir (exp_dir);
5714 if (exp_names->size () == 0)
5715 {
5716 delete exp_names;
5717 return NULL;
5718 }
5719 exp_names->sort (dir_name_cmp);
5720 return exp_names;
5721 }
5722
5723 bool
5724 Experiment::create_dir (char *dname)
5725 {
5726 if (mkdir (dname, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0)
5727 {
5728 return true;
5729 }
5730 dbe_stat_t sbuf;
5731 if (dbe_stat (dname, &sbuf) != 0 || S_ISDIR (sbuf.st_mode) == 0)
5732 {
5733 char *buf = dbe_sprintf (GTXT ("Unable to create directory `%s'\n"),
5734 dname);
5735 errorq->append (new Emsg (CMSG_ERROR, buf));
5736 free (buf);
5737 return false;
5738 }
5739 return true;
5740 }
5741
5742 char *
5743 Experiment::get_arch_name ()
5744 {
5745 if (arch_name == NULL)
5746 {
5747 // Determine the master experiment directory.
5748 // omazur: should do it in a less hacky way. XXXX
5749 char *ptr = strstr_r (expt_name, DESCENDANT_EXPT_KEY);
5750 ptr = ptr ? ptr + 3 : expt_name + strlen (expt_name);
5751 arch_name = dbe_sprintf (NTXT ("%.*s/%s"), (int) (ptr - expt_name),
5752 expt_name, SP_ARCHIVES_DIR);
5753 }
5754 return arch_name;
5755 }
5756
5757 char *
5758 Experiment::get_fndr_arch_name ()
5759 {
5760 if (fndr_arch_name == NULL)
5761 // Determine the founder experiment directory.
5762 fndr_arch_name = dbe_strdup (get_arch_name ());
5763 return fndr_arch_name;
5764 }
5765
5766 enum
5767 {
5768 HASH_NAME_LEN = 11 // (64 / 6 + 1) = 11
5769 };
5770
5771 static char *
5772 get_hash_string (char buf[HASH_NAME_LEN + 1], uint64_t hash)
5773 {
5774 static const char *har =
5775 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
5776 for (int i = 0; i < HASH_NAME_LEN; i++)
5777 {
5778 buf[i] = har[hash & 0x3f];
5779 hash = hash >> 6;
5780 }
5781 buf[HASH_NAME_LEN] = 0;
5782 return buf;
5783 }
5784
5785 char *
5786 Experiment::getNameInArchive (const char *fname, bool archiveFile)
5787 {
5788 char *aname = get_archived_name (fname, archiveFile);
5789 char *ret = dbe_sprintf (NTXT ("%s/%s"), get_arch_name (), aname);
5790 free (aname);
5791 return ret;
5792 }
5793
5794 #define MAX_ARCHIVE_FILENAME_LEN (256 - HASH_NAME_LEN - 2)
5795
5796 char *
5797 Experiment::get_archived_name (const char *fname, bool archiveFile)
5798 {
5799 char *bname = get_basename (fname);
5800
5801 // dirname_hash:
5802 char dirnameHash[HASH_NAME_LEN + 1];
5803 // Treat "a.out" and "./a.out" equally
5804 uint64_t hash = bname != fname ? crc64 (fname, bname - fname)
5805 : crc64 (NTXT ("./"), 2);
5806 get_hash_string (dirnameHash, hash);
5807
5808 char *ret;
5809 long bname_len = dbe_sstrlen (bname);
5810 if (bname_len > MAX_ARCHIVE_FILENAME_LEN)
5811 {
5812 char basenameHash[HASH_NAME_LEN + 1];
5813 hash = crc64 (bname, bname_len);
5814 get_hash_string (basenameHash, hash);
5815 ret = dbe_sprintf ("%.*s%c%s_%s",
5816 MAX_ARCHIVE_FILENAME_LEN - HASH_NAME_LEN - 1,
5817 bname, archiveFile ? '.' : '_',
5818 dirnameHash, basenameHash);
5819 }
5820 else
5821 ret = dbe_sprintf ("%s%c%s", bname, archiveFile ? '.' : '_', dirnameHash);
5822 return ret;
5823 }
5824
5825 char *
5826 Experiment::checkFileInArchive (const char *fname, bool archiveFile)
5827 {
5828 if (archiveMap)
5829 {
5830 char *aname = get_archived_name (fname, archiveFile);
5831 DbeFile *df = archiveMap->get (aname);
5832 free (aname);
5833 if (df)
5834 return strdup (df->get_location ());
5835 return NULL;
5836 }
5837 if (founder_exp)
5838 return founder_exp->checkFileInArchive (fname, archiveFile);
5839 return NULL;
5840 }
5841
5842
5843 // Comparing SegMem
5844
5845 static int
5846 SegMemCmp (const void *a, const void *b)
5847 {
5848 SegMem *item1 = *((SegMem **) a);
5849 SegMem *item2 = *((SegMem **) b);
5850 return item1->unload_time > item2->unload_time ? 1 :
5851 item1->unload_time == item2->unload_time ? 0 : -1;
5852 }
5853
5854 SegMem*
5855 Experiment::update_ts_in_maps (Vaddr addr, hrtime_t ts)
5856 {
5857 Vector<SegMem *> *segMems = (Vector<SegMem *> *) maps->values ();
5858 if (!segMems->is_sorted ())
5859 {
5860 Dprintf (DEBUG_MAPS, NTXT ("update_ts_in_maps: segMems.size=%lld\n"), (long long) segMems->size ());
5861 segMems->sort (SegMemCmp);
5862 }
5863 for (int i = 0, sz = segMems ? segMems->size () : 0; i < sz; i++)
5864 {
5865 SegMem *sm = segMems->fetch (i);
5866 if (ts < sm->unload_time)
5867 {
5868 for (; i < sz; i++)
5869 {
5870 sm = segMems->fetch (i);
5871 if ((addr >= sm->base) && (addr < sm->base + sm->size))
5872 {
5873 Dprintf (DEBUG_MAPS,
5874 "update_ts_in_maps: old:%u.%09u -> %u.%09u addr=0x%08llx size=%lld\n",
5875 (unsigned) (sm->load_time / NANOSEC),
5876 (unsigned) (sm->load_time % NANOSEC),
5877 (unsigned) (ts / NANOSEC), (unsigned) (ts % NANOSEC),
5878 (unsigned long long) sm->base, (long long) sm->size);
5879 maps->remove (sm->base, sm->load_time);
5880 sm->load_time = ts;
5881 maps->insert (sm->base, ts, sm);
5882 return sm;
5883 }
5884 }
5885 }
5886 }
5887 Dprintf (DEBUG_MAPS, "update_ts_in_maps: NOT FOUND %u.%09u addr=0x%08llx\n",
5888 (unsigned) (ts / NANOSEC), (unsigned) (ts % NANOSEC),
5889 (unsigned long long) addr);
5890 return NULL;
5891 }
5892
5893 DbeInstr*
5894 Experiment::map_Vaddr_to_PC (Vaddr addr, hrtime_t ts)
5895 {
5896 // Look up in the hash table first
5897 int hash = (((int) addr) >> 8) & (HTableSize - 1);
5898 SegMem *si = smemHTable[hash];
5899 if (si == NULL || addr < si->base || addr >= si->base + si->size
5900 || ts < si->load_time || ts >= si->unload_time)
5901 {
5902 // Not in the hash table
5903 si = (SegMem*) maps->locate (addr, ts);
5904 if (si == NULL || addr < si->base || addr >= si->base + si->size
5905 || ts < si->load_time || ts >= si->unload_time)
5906 {
5907 si = update_ts_in_maps (addr, ts);
5908 if (si == NULL)
5909 return dbeSession->get_Unknown_Function ()->find_dbeinstr (PCInvlFlag, addr);
5910 }
5911 smemHTable[hash] = si;
5912 }
5913
5914 // Calculate the file offset of 'addr'
5915 uint64_t f_offset = si->get_file_offset () + (addr - si->base);
5916
5917 DbeInstr *instr;
5918 if (si->obj->get_type () == Histable::LOADOBJECT)
5919 {
5920 LoadObject *lo = (LoadObject*) si->obj;
5921 lo->sync_read_stabs ();
5922 instr = lo->find_dbeinstr (f_offset);
5923 }
5924 else
5925 {
5926 int hash2 = ((((int) addr) & 0xFFFC00) | (((int) f_offset) >> 2))
5927 & (HTableSize - 1);
5928 instr = instHTable[hash2];
5929 if (instr == NULL || instr->func != si->obj || instr->addr != f_offset)
5930 {
5931 // Not in the hash table
5932 Function *fp = (Function *) si->obj;
5933 instr = fp->find_dbeinstr (0, f_offset);
5934 instHTable[hash2] = instr;
5935 }
5936 }
5937 if (!instr->func->isUsed)
5938 {
5939 instr->func->isUsed = true;
5940 instr->func->module->isUsed = true;
5941 instr->func->module->loadobject->isUsed = true;
5942 }
5943 return instr;
5944 }
5945
5946 Sample *
5947 Experiment::map_event_to_Sample (hrtime_t ts)
5948 {
5949 Sample *sample;
5950 int index;
5951
5952 // Check if the last used sample is the right one,
5953 // if not then find it.
5954 if (sample_last_used && ts >= sample_last_used->start_time
5955 && ts <= sample_last_used->end_time)
5956 return sample_last_used;
5957
5958 Vec_loop (Sample*, samples, index, sample)
5959 {
5960 if ((ts >= sample->start_time) &&
5961 (ts <= sample->end_time))
5962 {
5963 sample_last_used = sample;
5964 return sample;
5965 }
5966 }
5967 return (Sample*) NULL;
5968 }
5969
5970 GCEvent *
5971 Experiment::map_event_to_GCEvent (hrtime_t ts)
5972 {
5973 GCEvent *gcevent;
5974 int index;
5975
5976 // Check if the last used sample is the right one,
5977 // if not then find it.
5978 if (gcevent_last_used && ts >= gcevent_last_used->start
5979 && ts <= gcevent_last_used->end)
5980 return gcevent_last_used;
5981 Vec_loop (GCEvent*, gcevents, index, gcevent)
5982 {
5983 if ((ts >= gcevent->start) &&
5984 (ts <= gcevent->end))
5985 {
5986 gcevent_last_used = gcevent;
5987 return gcevent;
5988 }
5989 }
5990 return (GCEvent*) NULL;
5991 }
5992
5993 DbeInstr*
5994 Experiment::map_jmid_to_PC (Vaddr mid, int bci, hrtime_t ts)
5995 {
5996 if (mid == 0 || jmaps == NULL)
5997 // special case: no Java stack was recorded, bci - error code
5998 return dbeSession->get_JUnknown_Function ()->find_dbeinstr (0, bci);
5999
6000 JMethod *jmthd = jmidHTable->get (mid);
6001 if (jmthd == NULL)
6002 {
6003 jmthd = (JMethod *) jmaps->locate_exact_match (mid, ts);
6004 if (jmthd)
6005 jmidHTable->put (mid, jmthd);
6006 }
6007 if (jmthd == NULL || jmthd->get_type () != Histable::FUNCTION)
6008 return dbeSession->get_JUnknown_Function ()->find_dbeinstr (0, (uint64_t) mid);
6009 return jmthd->find_dbeinstr (0, bci);
6010 }
6011
6012 Emsg *
6013 Experiment::fetch_comments ()
6014 {
6015 return commentq->fetch ();
6016 }
6017
6018 Emsg *
6019 Experiment::fetch_runlogq ()
6020 {
6021 return runlogq->fetch ();
6022 }
6023
6024 Emsg *
6025 Experiment::fetch_errors ()
6026 {
6027 return errorq->fetch ();
6028 }
6029
6030 Emsg *
6031 Experiment::fetch_warnings ()
6032 {
6033 return warnq->fetch ();
6034 }
6035
6036 Emsg *
6037 Experiment::fetch_notes ()
6038 {
6039 return notesq->fetch ();
6040 }
6041
6042 Emsg *
6043 Experiment::fetch_ifreq ()
6044 {
6045 return ifreqq->fetch ();
6046 }
6047
6048 Emsg *
6049 Experiment::fetch_pprocq ()
6050 {
6051 return pprocq->fetch ();
6052 }
6053
6054 int
6055 Experiment::read_dyntext_file ()
6056 {
6057 dyntext_name = dbe_sprintf ("%s/%s", expt_name, SP_DYNTEXT_FILE);
6058 Data_window *dwin = new Data_window (dyntext_name);
6059 if (dwin->not_opened ())
6060 {
6061 delete dwin;
6062 return 1;
6063 }
6064 dwin->need_swap_endian = need_swap_endian;
6065
6066 Function *fp = NULL;
6067 char *progress_msg = NULL; // Message for the progress bar
6068 for (int64_t offset = 0;;)
6069 {
6070 DT_common *cpckt = (DT_common *) dwin->bind (offset, sizeof (DT_common));
6071 if (cpckt == NULL)
6072 break;
6073 size_t cpcktsize = dwin->decode (cpckt->size);
6074 cpckt = (DT_common *) dwin->bind (offset, cpcktsize);
6075 if (cpckt == NULL)
6076 break;
6077 switch (dwin->decode (cpckt->type))
6078 {
6079 case DT_HEADER:
6080 {
6081 DT_header *hdr = (DT_header*) cpckt;
6082 hrtime_t ts = dwin->decode (hdr->time) + exp_start_time;
6083 SegMem *si = (SegMem*) maps->locate (dwin->decode (hdr->vaddr), ts);
6084 fp = si ? (Function *) si->obj : NULL;
6085 if (fp && (fp->get_type () != Histable::FUNCTION
6086 || !(fp->flags & FUNC_FLAG_DYNAMIC)))
6087 fp = NULL;
6088 break;
6089 }
6090 case DT_CODE:
6091 if (fp)
6092 {
6093 fp->img_fname = dyntext_name;
6094 fp->img_offset = offset + sizeof (DT_common);
6095 if ((platform != Intel) && (platform != Amd64))
6096 { //ARCH(SPARC)
6097 // Find out 'save' instruction address for SPARC
6098 char *ptr = ((char*) cpckt) + sizeof (DT_common);
6099 size_t img_size = cpcktsize - sizeof (DT_common);
6100 for (size_t i = 0; i < img_size; i += 4)
6101 if (ptr[i] == (char) 0x9d && ptr[i + 1] == (char) 0xe3)
6102 {
6103 fp->save_addr = i;
6104 break;
6105 }
6106 }
6107 }
6108 break;
6109 case DT_SRCFILE:
6110 if (fp)
6111 {
6112 char *srcname = dbe_strndup (((char*) cpckt) + sizeof (DT_common),
6113 cpcktsize - sizeof (DT_common));
6114 LoadObject *ds = fp->module ? fp->module->loadobject : NULL;
6115 assert (ds != NULL);
6116 Module *mod = dbeSession->createModule (ds, NULL);
6117 mod->set_file_name (srcname);
6118 //}
6119 if (fp->module)
6120 {
6121 // It's most likely (unknown). Remove fp from it.
6122 long idx = fp->module->functions->find (fp);
6123 if (idx >= 0)
6124 fp->module->functions->remove (idx);
6125 }
6126 fp->module = mod;
6127 mod->functions->append (fp);
6128 }
6129 break;
6130 case DT_LTABLE:
6131 if (fp)
6132 {
6133 DT_lineno *ltab = (DT_lineno*) ((char*) cpckt + sizeof (DT_common));
6134 size_t sz = (cpcktsize - sizeof (DT_common)) / sizeof (DT_lineno);
6135 if (sz <= 0)
6136 break;
6137 // Take care of the progress bar
6138 static int percent = 0;
6139 static long deltaReport = sz / 100; // 1000;
6140 static long nextReport = 0;
6141 static long progress_count = 0;
6142 fp->pushSrcFile (fp->getDefSrc (), 0);
6143 for (size_t i = 0; i < sz; i++)
6144 {
6145 int lineno = dwin->decode (ltab[i].lineno);
6146 if (fp->usrfunc != NULL)
6147 {
6148 // Update progress bar
6149 if (dbeSession->is_interactive ())
6150 {
6151 if (progress_count == nextReport)
6152 {
6153 if (percent < 99)
6154 {
6155 percent++;
6156 if (NULL == progress_msg)
6157 {
6158 progress_msg = dbe_sprintf (GTXT ("Processing Dynamic Text: %s"),
6159 get_basename (expt_name));
6160 }
6161 theApplication->set_progress (percent, progress_msg);
6162 nextReport += deltaReport;
6163 }
6164 }
6165 progress_count++;
6166 }
6167 DbeLine *dbeline = fp->usrfunc->mapPCtoLine (lineno, NULL);
6168 lineno = dbeline != NULL ? dbeline->lineno : -1;
6169 }
6170 fp->add_PC_info (dwin->decode (ltab[i].offset), lineno);
6171 }
6172 fp->popSrcFile ();
6173 }
6174 break;
6175 default:
6176 // skip unknown records
6177 break;
6178 }
6179 offset += cpcktsize;
6180 }
6181 free (progress_msg);
6182 delete dwin;
6183 return 0;
6184 }
6185
6186 uint32_t
6187 Experiment::mapTagValue (Prop_type prop, uint64_t value)
6188 {
6189 Vector<Histable*> *objs = tagObjs->fetch (prop);
6190 int lt = 0;
6191 int rt = objs->size () - 1;
6192 while (lt <= rt)
6193 {
6194 int md = (lt + rt) / 2;
6195 Other *obj = (Other*) objs->fetch (md);
6196 if (obj->value64 < value)
6197 lt = md + 1;
6198 else if (obj->value64 > value)
6199 rt = md - 1;
6200 else
6201 return obj->tag;
6202 }
6203
6204 uint32_t tag;
6205 if (sparse_threads && (prop == PROP_THRID || prop == PROP_LWPID))
6206 tag = objs->size () + 1; // "+ 1" related to 7038295
6207 else
6208 tag = (int) value; // truncation; See 6788767
6209
6210 Other *obj = new Other ();
6211 obj->value64 = value;
6212 obj->tag = tag;
6213 if (lt == objs->size ())
6214 objs->append (obj);
6215 else
6216 objs->insert (lt, obj);
6217
6218 // Update min and max tags
6219 if (prop == PROP_LWPID)
6220 {
6221 if ((uint64_t) tag < min_lwp)
6222 min_lwp = (uint64_t) tag;
6223 if ((uint64_t) tag > max_lwp)
6224 max_lwp = (uint64_t) tag;
6225 lwp_cnt++;
6226 }
6227 else if (prop == PROP_THRID)
6228 {
6229 if ((uint64_t) tag < min_thread)
6230 min_thread = (uint64_t) tag;
6231 if ((uint64_t) tag > max_thread)
6232 max_thread = (uint64_t) tag;
6233 thread_cnt++;
6234 }
6235 else if (prop == PROP_CPUID)
6236 {
6237 // On Solaris 8, we don't get CPU id -- don't change
6238 if (value != (uint64_t) - 1)
6239 {//YXXX is this related only to solaris 8?
6240 if ((uint64_t) tag < min_cpu)
6241 min_cpu = (uint64_t) tag;
6242 if ((uint64_t) tag > max_cpu)
6243 max_cpu = (uint64_t) tag;
6244 }
6245 cpu_cnt++;
6246 }
6247 return obj->tag;
6248 }
6249
6250 Vector<Histable*> *
6251 Experiment::getTagObjs (Prop_type prop)
6252 {
6253 return tagObjs->fetch (prop);
6254 }
6255
6256 Histable *
6257 Experiment::getTagObj (Prop_type prop, uint32_t tag)
6258 {
6259 Vector<Histable*> *objs = tagObjs->fetch (prop);
6260 if (objs == NULL)
6261 return NULL;
6262 for (int i = 0; i < objs->size (); i++)
6263 {
6264 Other *obj = (Other*) objs->fetch (i);
6265 if (obj->tag == tag)
6266 return obj;
6267 }
6268 return NULL;
6269 }
6270
6271 JThread *
6272 Experiment::map_pckt_to_Jthread (uint32_t tid, hrtime_t tstamp)
6273 {
6274 if (!has_java)
6275 return JTHREAD_DEFAULT;
6276 int lt = 0;
6277 int rt = jthreads_idx->size () - 1;
6278 while (lt <= rt)
6279 {
6280 int md = (lt + rt) / 2;
6281 JThread *jthread = jthreads_idx->fetch (md);
6282 if (jthread->tid < tid)
6283 lt = md + 1;
6284 else if (jthread->tid > tid)
6285 rt = md - 1;
6286 else
6287 {
6288 for (; jthread; jthread = jthread->next)
6289 if (tstamp >= jthread->start && tstamp < jthread->end)
6290 return jthread;
6291 break;
6292 }
6293 }
6294
6295 return JTHREAD_NONE;
6296 }
6297
6298 JThread*
6299 Experiment::get_jthread (uint32_t tid)
6300 {
6301 if (!has_java)
6302 return JTHREAD_DEFAULT;
6303 int lt = 0;
6304 int rt = jthreads_idx->size () - 1;
6305 while (lt <= rt)
6306 {
6307 int md = (lt + rt) / 2;
6308 JThread *jthread = jthreads_idx->fetch (md);
6309 if (jthread->tid < tid)
6310 lt = md + 1;
6311 else if (jthread->tid > tid)
6312 rt = md - 1;
6313 else
6314 {
6315 JThread *jthread_first = jthread;
6316 while ((jthread = jthread->next) != NULL)
6317 if (!jthread->is_system () &&
6318 jthread->jthr_id < jthread_first->jthr_id)
6319 jthread_first = jthread;
6320 return jthread_first;
6321 }
6322 }
6323
6324 return JTHREAD_NONE;
6325 }
6326
6327 // SS12 experiment
6328 DataDescriptor *
6329 Experiment::newDataDescriptor (int data_id, int flags,
6330 DataDescriptor *master_dDscr)
6331 {
6332 DataDescriptor *dataDscr = NULL;
6333 if (data_id >= 0 && data_id < dataDscrs->size ())
6334 {
6335 dataDscr = dataDscrs->fetch (data_id);
6336 if (dataDscr != NULL)
6337 return dataDscr;
6338 }
6339
6340 assert (data_id >= 0 && data_id < DATA_LAST);
6341 const char *nm = get_prof_data_type_name (data_id);
6342 const char *uname = get_prof_data_type_uname (data_id);
6343
6344 if (master_dDscr)
6345 dataDscr = new DataDescriptor (data_id, nm, uname, master_dDscr);
6346 else
6347 dataDscr = new DataDescriptor (data_id, nm, uname, flags);
6348 dataDscrs->store (data_id, dataDscr);
6349 return dataDscr;
6350 }
6351
6352 Vector<DataDescriptor*> *
6353 Experiment::getDataDescriptors ()
6354 {
6355 Vector<DataDescriptor*> *result = new Vector<DataDescriptor*>;
6356 for (int i = 0; i < dataDscrs->size (); ++i)
6357 {
6358 DataDescriptor *dd;
6359 dd = get_raw_events (i); // force data fetch
6360 if (dd != NULL)
6361 result->append (dd);
6362 }
6363 return result;
6364 }
6365
6366 DataDescriptor *
6367 Experiment::getDataDescriptor (int data_id)
6368 {
6369 if (data_id < 0 || data_id >= dataDscrs->size ())
6370 return NULL;
6371 return dataDscrs->fetch (data_id);
6372 }
6373
6374 PacketDescriptor *
6375 Experiment::newPacketDescriptor (int kind, DataDescriptor *dDscr)
6376 {
6377 PacketDescriptor *pDscr = new PacketDescriptor (dDscr);
6378 pcktDscrs->store (kind, pDscr);
6379 return pDscr;
6380 }
6381
6382 PacketDescriptor *
6383 Experiment::getPacketDescriptor (int kind)
6384 {
6385 if (kind < 0 || kind >= pcktDscrs->size ())
6386 return NULL;
6387 return pcktDscrs->fetch (kind);
6388 }
6389
6390 void
6391 Experiment::set_clock (int clk)
6392 {
6393 if (clk > 0)
6394 {
6395 if (maxclock < clk)
6396 {
6397 maxclock = clk;
6398 clock = maxclock;
6399 }
6400 if (minclock == 0 || minclock > clk)
6401 minclock = clk;
6402 }
6403 }
6404
6405 bool
6406 JThread::is_system ()
6407 {
6408 if (group_name == NULL)
6409 return false;
6410 return strcmp (group_name, NTXT ("system")) == 0;
6411 }
6412
6413 void
6414 Experiment::dump_stacks (FILE *outfile)
6415 {
6416 cstack->print (outfile);
6417 }
6418
6419 void
6420 Experiment::dump_map (FILE *outfile)
6421 {
6422 int index;
6423 SegMem *s;
6424 fprintf (outfile, GTXT ("Experiment %s\n"), get_expt_name ());
6425 fprintf (outfile, GTXT ("Address Size (hex) Load time Unload time Checksum Name\n"));
6426 Vec_loop (SegMem*, seg_items, index, s)
6427 {
6428 timestruc_t load;
6429 timestruc_t unload;
6430 hr2timestruc (&load, (s->load_time - exp_start_time));
6431 if (load.tv_nsec < 0)
6432 {
6433 load.tv_sec--;
6434 load.tv_nsec += NANOSEC;
6435 }
6436 if (s->unload_time == MAX_TIME)
6437 {
6438 unload.tv_sec = 0;
6439 unload.tv_nsec = 0;
6440 }
6441 else
6442 hr2timestruc (&unload, (s->unload_time - exp_start_time));
6443 if (load.tv_nsec < 0)
6444 {
6445 load.tv_sec--;
6446 load.tv_nsec += NANOSEC;
6447 }
6448 fprintf (outfile,
6449 "0x%08llx %8lld (0x%08llx) %5lld.%09lld %5lld.%09lld \"%s\"\n",
6450 (long long) s->base, (long long) s->size, (long long) s->size,
6451 (long long) load.tv_sec, (long long) load.tv_nsec,
6452 (long long) unload.tv_sec, (long long) unload.tv_nsec,
6453 s->obj->get_name ());
6454 }
6455 fprintf (outfile, NTXT ("\n"));
6456 }
6457
6458 /**
6459 * Copy file to archive
6460 * @param name
6461 * @param aname
6462 * @param hide_msg
6463 * @return 0 - success, 1 - error
6464 */
6465 int
6466 Experiment::copy_file_to_archive (const char *name, const char *aname, int hide_msg)
6467 {
6468 errno = 0;
6469 int fd_w = ::open64 (aname, O_WRONLY | O_CREAT | O_EXCL, 0644);
6470 if (fd_w == -1)
6471 {
6472 if (errno == EEXIST)
6473 return 0;
6474 fprintf (stderr, GTXT ("gp-archive: unable to copy `%s': %s\n"),
6475 name, STR (strerror (errno)));
6476 return 1;
6477 }
6478
6479 if (dbe_stat_file (name, NULL) != 0)
6480 {
6481 fprintf (stderr, GTXT ("gp-archive: cannot access file `%s': %s\n"),
6482 name, STR (strerror (errno)));
6483 close (fd_w);
6484 return 1;
6485 }
6486
6487 int fd_r = ::open64 (name, O_RDONLY);
6488 if (fd_r == -1)
6489 {
6490 fprintf (stderr, GTXT ("gp-archive: unable to open `%s': %s\n"),
6491 name, strerror (errno));
6492 close (fd_w);
6493 unlink (aname);
6494 return 1;
6495 }
6496
6497 if (!hide_msg)
6498 fprintf (stderr, GTXT ("Copying `%s' to `%s'\n"), name, aname);
6499 bool do_unlink = false;
6500 for (;;)
6501 {
6502 unsigned char buf[65536];
6503 int n, n1;
6504 n = (int) read (fd_r, (void *) buf, sizeof (buf));
6505 if (n <= 0)
6506 break;
6507 n1 = (int) write (fd_w, buf, n);
6508 if (n != n1)
6509 {
6510 fprintf (stderr, GTXT ("gp-archive: unable to write %d bytes to `%s': %s\n"),
6511 n, aname, STR (strerror (errno)));
6512 do_unlink = true;
6513 break;
6514 }
6515 }
6516 close (fd_w);
6517
6518 dbe_stat_t s_buf;
6519 if (fstat64 (fd_r, &s_buf) == 0)
6520 {
6521 struct utimbuf u_buf;
6522 u_buf.actime = s_buf.st_atime;
6523 u_buf.modtime = s_buf.st_mtime;
6524 utime (aname, &u_buf);
6525 }
6526 close (fd_r);
6527 if (do_unlink)
6528 {
6529 if (!hide_msg)
6530 fprintf (stderr, GTXT ("gp-archive: remove %s\n"), aname);
6531 unlink (aname);
6532 return 1;
6533 }
6534 return 0;
6535 }
6536
6537 /**
6538 * Copy file to common archive
6539 * Algorithm:
6540 * Calculate checksum
6541 * Generate file name to be created in common archive
6542 * Check if it is not in common archive yet
6543 * Copy file to the common archive directory if it is not there yet
6544 * Create symbolic link: "aname" -> "caname", where "caname" is the name in common archive
6545 * @param name - original file name
6546 * @param aname - file name in experiment archive
6547 * @param common_archive - common archive directory
6548 * @return 0 - success, 1 - error
6549 */
6550 int
6551 Experiment::copy_file_to_common_archive (const char *name, const char *aname,
6552 int hide_msg,
6553 const char *common_archive,
6554 int relative_path)
6555 {
6556 if (!name || !aname || !common_archive)
6557 {
6558 if (!name)
6559 fprintf (stderr, GTXT ("gp-archive: Internal error: file name is NULL\n"));
6560 if (!aname)
6561 fprintf (stderr, GTXT ("gp-archive: Internal error: file name in archive is NULL\n"));
6562 if (!common_archive)
6563 fprintf (stderr, GTXT ("gp-archive: Internal error: path to common archive is NULL\n"));
6564 return 1;
6565 }
6566 // Check if file is already archived
6567 if (dbe_stat (aname, NULL) == 0)
6568 return 0; // File is already archived
6569 // Generate full path to common archive directory
6570 char *cad = NULL;
6571 char *abs_aname = NULL;
6572 if ((common_archive[0] != '/') || (aname[0] != '/'))
6573 {
6574 long size = pathconf (NTXT ("."), _PC_PATH_MAX);
6575 if (size < 0)
6576 {
6577 fprintf (stderr, GTXT ("gp-archive: Fatal error: pathconf(\".\", _PC_PATH_MAX) failed\n"));
6578 return 1;
6579 }
6580 char *buf = (char *) malloc ((size_t) size);
6581 if (buf == NULL)
6582 {
6583 fprintf (stderr, GTXT ("gp-archive: Fatal error: unable to allocate memory\n"));
6584 return 1;
6585 }
6586 char *ptr = getcwd (buf, (size_t) size);
6587 if (ptr == NULL)
6588 {
6589 fprintf (stderr, GTXT ("gp-archive: Fatal error: cannot determine current directory\n"));
6590 free (buf);
6591 return 1;
6592 }
6593 if (common_archive[0] != '/')
6594 cad = dbe_sprintf (NTXT ("%s/%s"), ptr, common_archive);
6595 else
6596 cad = dbe_strdup (common_archive);
6597 if (aname[0] != '/')
6598 abs_aname = dbe_sprintf (NTXT ("%s/%s"), ptr, aname);
6599 else
6600 abs_aname = dbe_strdup (aname);
6601 free (buf);
6602 }
6603 else
6604 {
6605 cad = dbe_strdup (common_archive);
6606 abs_aname = dbe_strdup (aname);
6607 }
6608 // Calculate checksum
6609 char * errmsg = NULL;
6610 uint32_t crcval = get_cksum (name, &errmsg);
6611 if (0 == crcval)
6612 { // error
6613 free (cad);
6614 free (abs_aname);
6615 if (NULL != errmsg)
6616 {
6617 fprintf (stderr, GTXT ("gp-archive: Fatal error: %s\n"), errmsg);
6618 free (errmsg);
6619 return 1;
6620 }
6621 fprintf (stderr,
6622 GTXT ("gp-archive: Fatal error: get_cksum(%s) returned %d\n"),
6623 name, crcval);
6624 return 1;
6625 }
6626 // Generate file name to be created in common archive
6627 char *fname = get_basename (name);
6628 char *abs_caname = dbe_sprintf (NTXT ("%s/%u_%s"), cad, crcval, fname);
6629 if (abs_caname == NULL)
6630 {
6631 free (cad);
6632 free (abs_aname);
6633 fprintf (stderr,
6634 GTXT ("gp-archive: Fatal error: unable to allocate memory\n"));
6635 return 1;
6636 }
6637 // Check if full name is not too long
6638 long len = dbe_sstrlen (abs_caname);
6639 long max = pathconf (cad, _PC_PATH_MAX);
6640 if ((max < 0) || (len <= 0))
6641 { // unknown error
6642 fprintf (stderr, GTXT ("gp-archive: Fatal error: pathconf(%s, _PC_PATH_MAX) failed\n"),
6643 cad);
6644 free (abs_caname);
6645 free (cad);
6646 free (abs_aname);
6647 return 1;
6648 }
6649 if (len >= max)
6650 {
6651 // Try to truncate the name
6652 if ((len - max) <= dbe_sstrlen (fname))
6653 {
6654 // Yes, we can do it
6655 abs_caname[max - 1] = 0;
6656 if (!hide_msg)
6657 fprintf (stderr, GTXT ("gp-gp-archive: file path is too long - truncated:%s\n"),
6658 abs_caname);
6659 }
6660 }
6661 // Check if file name is not too long
6662 char *cafname = get_basename (abs_caname);
6663 len = dbe_sstrlen (cafname);
6664 max = pathconf (cad, _PC_NAME_MAX);
6665 if ((max < 0) || (len <= 0))
6666 { // unknown error
6667 fprintf (stderr, GTXT ("gp-archive: Fatal error: pathconf(%s, _PC_NAME_MAX) failed\n"),
6668 cad);
6669 free (abs_caname);
6670 free (cad);
6671 free (abs_aname);
6672 return 1;
6673 }
6674 if (len >= max)
6675 {
6676 // Try to truncate the name
6677 if ((len - max) <= dbe_sstrlen (fname))
6678 {
6679 // Yes, we can do it
6680 cafname[max - 1] = 0;
6681 if (!hide_msg)
6682 fprintf (stderr, GTXT ("gp-archive: file name is too long - truncated:%s\n"),
6683 abs_caname);
6684 }
6685 }
6686 // Copy file to the common archive directory if it is not there yet
6687 int res = 0;
6688 if (dbe_stat_file (abs_caname, NULL) != 0)
6689 {
6690 // Use temporary file to avoid synchronization problems
6691 char *t = dbe_sprintf ("%s/archive_%llx", cad, (unsigned long long) gethrtime());
6692 free (cad);
6693 // Copy file to temporary file
6694 res = copy_file_to_archive (name, t, hide_msg); // hide messages
6695 if (res != 0)
6696 {
6697 fprintf (stderr, GTXT ("gp-archive: Fatal error: cannot copy file %s to temporary file: %s\n"),
6698 name, t);
6699 unlink (t);
6700 free (t);
6701 free (abs_caname);
6702 free (abs_aname);
6703 return 1;
6704 }
6705 // Set read-only permissions
6706 dbe_stat_t statbuf;
6707 if (0 == dbe_stat_file (name, &statbuf))
6708 {
6709 mode_t mask = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
6710 mode_t mode = statbuf.st_mode & mask;
6711 chmod (t, mode);
6712 }
6713 // Try to rename temporary file "t" to "abs_caname"
6714 // res = link(t, abs_caname); // link() fails on some f/s - use rename()
6715 res = rename (t, abs_caname);
6716 if (res != 0)
6717 {
6718 if (errno != EEXIST)
6719 {
6720 fprintf (stderr, GTXT ("gp-archive: Fatal error: rename(%s, %s) returned error: %d\n"),
6721 t, abs_caname, res);
6722 unlink (t);
6723 free (t);
6724 free (abs_caname);
6725 free (abs_aname);
6726 return 1;
6727 }
6728 // File "abs_caname" is already there - continue
6729 }
6730 unlink (t);
6731 free (t);
6732 }
6733 else
6734 free (cad);
6735 char *lname = NULL;
6736 if (relative_path)
6737 {
6738 if (common_archive[0] != '/' && aname[0] != '/')
6739 {
6740 // compare one relative path to another and find common beginning
6741 char *rel_caname = dbe_sprintf ("%s/%s", common_archive, cafname);
6742 if (rel_caname == NULL)
6743 {
6744 fprintf (stderr, GTXT ("gp-archive: Fatal error: unable to allocate memory\n"));
6745 return 1;
6746 }
6747 lname = get_relative_link (rel_caname, aname);
6748 free (rel_caname);
6749 }
6750 else
6751 {
6752 if (abs_aname == NULL)
6753 {
6754 fprintf (stderr, GTXT ("gp-archive: Fatal error: unable to allocate memory\n"));
6755 return 1;
6756 }
6757 lname = get_relative_link (abs_caname, abs_aname);
6758 }
6759 }
6760 else // absolute path
6761 lname = dbe_strdup (abs_caname);
6762 free (abs_aname);
6763 if (lname == NULL)
6764 {
6765 fprintf (stderr, GTXT ("gp-archive: Fatal error: unable to allocate memory\n"));
6766 return 1;
6767 }
6768 // Create symbolic link: aname -> lname
6769 if (dbe_stat_file (abs_caname, NULL) == 0)
6770 {
6771 res = symlink (lname, aname);
6772 if (res != 0)
6773 {
6774 fprintf (stderr, GTXT ("gp-archive: Fatal error: symlink(%s, %s) returned error: %d (errno=%s)\n"),
6775 lname, aname, res, strerror (errno));
6776 free (abs_caname);
6777 free (lname);
6778 return 1;
6779 }
6780 if (!hide_msg)
6781 fprintf (stderr, GTXT ("Created symbolic link %s to file in common archive: %s\n"),
6782 aname, lname);
6783 }
6784 else
6785 {
6786 fprintf (stderr, GTXT ("gp-archive: Internal error: file does not exist in common archive: %s\n"),
6787 abs_caname);
6788 res = 1;
6789 }
6790 free (abs_caname);
6791 free (lname);
6792 return res;
6793 }
6794
6795 /**
6796 * Copy file to archive
6797 * @param name
6798 * @param aname
6799 * @param hide_msg
6800 * @param common_archive
6801 * @return 0 - success
6802 */
6803 int
6804 Experiment::copy_file (char *name, char *aname, int hide_msg, char *common_archive, int relative_path)
6805 {
6806 if (common_archive)
6807 {
6808 if (0 == copy_file_to_common_archive (name, aname, hide_msg,
6809 common_archive, relative_path))
6810 return 0;
6811 // Error. For now - fatal error. Message is already printed.
6812 fprintf (stderr, GTXT ("gp-archive: Fatal error: cannot copy file %s to common archive %s\n"),
6813 name, common_archive);
6814 return 1;
6815 }
6816 return (copy_file_to_archive (name, aname, hide_msg));
6817 }
6818
6819 LoadObject *
6820 Experiment::createLoadObject (const char *path, uint64_t chksum)
6821 {
6822 LoadObject *lo = dbeSession->createLoadObject (path, chksum);
6823 if (lo->firstExp == NULL)
6824 lo->firstExp = this;
6825 return lo;
6826 }
6827
6828 LoadObject *
6829 Experiment::createLoadObject (const char *path, const char *runTimePath)
6830 {
6831 DbeFile *df = findFileInArchive (path, runTimePath);
6832 if (df && (df->get_stat () == NULL))
6833 df = NULL; // No access to file
6834 LoadObject *lo = dbeSession->createLoadObject (path, runTimePath, df);
6835 if (df && (lo->dbeFile->get_location (false) == NULL))
6836 {
6837 lo->dbeFile->set_location (df->get_location ());
6838 lo->dbeFile->inArchive = df->inArchive;
6839 lo->dbeFile->sbuf = df->sbuf;
6840 lo->dbeFile->experiment = df->experiment;
6841 lo->firstExp = df->experiment;
6842 }
6843 if (lo->firstExp == NULL)
6844 {
6845 lo->firstExp = this;
6846 lo->dbeFile->experiment = this;
6847 }
6848 return lo;
6849 }
6850
6851 SourceFile *
6852 Experiment::get_source (const char *path)
6853 {
6854 if (founder_exp && (founder_exp != this))
6855 return founder_exp->get_source (path);
6856 if (sourcesMap == NULL)
6857 sourcesMap = new StringMap<SourceFile*>(1024, 1024);
6858 if (strncmp (path, NTXT ("./"), 2) == 0)
6859 path += 2;
6860 SourceFile *sf = sourcesMap->get (path);
6861 if (sf)
6862 return sf;
6863 char *fnm = checkFileInArchive (path, false);
6864 if (fnm)
6865 {
6866 sf = new SourceFile (path);
6867 dbeSession->append (sf);
6868 DbeFile *df = sf->dbeFile;
6869 df->set_location (fnm);
6870 df->inArchive = true;
6871 df->check_access (fnm); // init 'sbuf'
6872 df->sbuf.st_mtime = 0; // Don't check timestamps
6873 free (fnm);
6874 }
6875 else
6876 sf = dbeSession->createSourceFile (path);
6877 sourcesMap->put (path, sf);
6878 return sf;
6879 }
6880
6881 Vector<Histable*> *
6882 Experiment::get_comparable_objs ()
6883 {
6884 update_comparable_objs ();
6885 if (comparable_objs || dbeSession->expGroups->size () <= 1)
6886 return comparable_objs;
6887 comparable_objs = new Vector<Histable*>(dbeSession->expGroups->size ());
6888 for (long i = 0, sz = dbeSession->expGroups->size (); i < sz; i++)
6889 {
6890 ExpGroup *gr = dbeSession->expGroups->get (i);
6891 if (groupId == gr->groupId)
6892 {
6893 comparable_objs->append (this);
6894 continue;
6895 }
6896 Histable *h = NULL;
6897 for (long i1 = 0, sz1 = gr->exps ? gr->exps->size () : 0; i1 < sz1; i1++)
6898 {
6899 Experiment *exp = gr->exps->get (i1);
6900 if ((exp->comparable_objs == NULL) && (dbe_strcmp (utargname, exp->utargname) == 0))
6901 {
6902 exp->phaseCompareIdx = phaseCompareIdx;
6903 h = exp;
6904 h->comparable_objs = comparable_objs;
6905 break;
6906 }
6907 }
6908 comparable_objs->append (h);
6909 }
6910 dump_comparable_objs ();
6911 return comparable_objs;
6912 }
6913
6914 DbeFile *
6915 Experiment::findFileInArchive (const char *fname)
6916 {
6917 if (archiveMap)
6918 {
6919 char *aname = get_archived_name (fname);
6920 DbeFile *df = archiveMap->get (aname);
6921 free (aname);
6922 return df;
6923 }
6924 if (founder_exp)
6925 return founder_exp->findFileInArchive (fname);
6926 return NULL;
6927 }
6928
6929 DbeFile *
6930 Experiment::findFileInArchive (const char *className, const char *runTimePath)
6931 {
6932 DbeFile *df = NULL;
6933 if (runTimePath)
6934 {
6935 const char *fnm = NULL;
6936 if (strncmp (runTimePath, NTXT ("zip:"), 4) == 0)
6937 fnm = runTimePath + 4;
6938 else if (strncmp (runTimePath, NTXT ("jar:file:"), 9) == 0)
6939 fnm = runTimePath + 9;
6940 if (fnm)
6941 {
6942 const char *s = strchr (fnm, '!');
6943 if (s)
6944 {
6945 char *s1 = dbe_strndup (fnm, s - fnm);
6946 df = findFileInArchive (s1);
6947 free (s1);
6948 }
6949 else
6950 df = findFileInArchive (fnm);
6951 if (df)
6952 df->filetype |= DbeFile::F_JAR_FILE;
6953 }
6954 else if (strncmp (runTimePath, NTXT ("file:"), 5) == 0)
6955 {
6956 fnm = runTimePath + 5;
6957 df = findFileInArchive (fnm);
6958 }
6959 else
6960 df = findFileInArchive (runTimePath);
6961 }
6962 if (df == NULL)
6963 df = findFileInArchive (className);
6964 return df;
6965 }
A mirror of the official binutils-gdb repository