]>
Commit | Line | Data |
---|---|---|
76bdc726 | 1 | /* Copyright (C) 2021-2023 Free Software Foundation, Inc. |
bb368aad VM |
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 | /* | |
22 | * The DbeView class represents a window into the data managed by a DbeSession | |
23 | * | |
24 | * A DbeView has a Settings class that determines the user preferences, | |
25 | * instantiated initially as a copy of the one in the DbeSession | |
26 | * that created it, or in the DbeView being cloned by the DbeSession | |
27 | * | |
28 | * A DbeView has a vector of Experiment pointers, matching the one in the | |
29 | * DbeSession, and a vector of enable bits governing which of the | |
30 | * Experiments are currently being used to process the data. | |
31 | * | |
32 | * A DbeView has three vectors of Metrics, one for functions, etc., | |
33 | * a second for callers/callees, and a third for dataspace/memoryspace. | |
34 | * | |
35 | * A DbeView has a vector of FilterSet's (q.v.), one for each Experiment, | |
36 | * used to determine how the data is filtered. | |
37 | * | |
38 | * Each DbeView has its own instantiation of the objects representing | |
39 | * the processed, filtered data. Currently these are a PathTree | |
40 | * for computing text-based metrics, a DataSpace for computing | |
41 | * data-based metrics, and a MemorySpace used for computing | |
42 | * memory-object-based metrics. | |
43 | */ | |
44 | ||
45 | #ifndef _DBEVIEW_H | |
46 | #define _DBEVIEW_H | |
47 | ||
48 | #include <stdio.h> | |
49 | #include "dbe_structs.h" | |
50 | #include "vec.h" | |
51 | #include "enums.h" | |
52 | #include "util.h" | |
53 | #include "DerivedMetrics.h" | |
54 | #include "Histable.h" | |
55 | #include "Hist_data.h" | |
56 | #include "Settings.h" | |
57 | #include "Metric.h" | |
58 | #include "Table.h" | |
59 | #include "PathTree.h" | |
60 | ||
61 | class Application; | |
62 | class DataView; | |
63 | class Experiment; | |
64 | class Expression; | |
65 | class FilterSet; | |
66 | class FilterNumeric; | |
67 | class FilterExp; | |
68 | class Function; | |
69 | class Histable; | |
70 | class MetricList; | |
71 | class Module; | |
72 | class Ovw_data; | |
73 | class PathTree; | |
74 | class DataSpace; | |
75 | class MemorySpace; | |
76 | class Stats_data; | |
77 | class LoadObject; | |
78 | class IOActivity; | |
79 | class HeapActivity; | |
80 | ||
81 | class DbeView | |
82 | { | |
83 | public: | |
84 | DbeView (Application *app, Settings *_settings, int _vindex); | |
85 | DbeView (DbeView *dbev, int _vindex); | |
86 | ~DbeView (); | |
87 | ||
88 | // Access functions for settings in the view | |
89 | Settings * | |
90 | get_settings () | |
91 | { | |
92 | return settings; | |
93 | }; | |
94 | ||
95 | // Get the list of tabs for this view | |
96 | Vector<DispTab*> * | |
97 | get_TabList () | |
98 | { | |
99 | return settings->get_TabList (); | |
100 | }; | |
101 | ||
102 | // Get the list of memory tabs for this view | |
103 | Vector<bool> * | |
104 | get_MemTabState () | |
105 | { | |
106 | return settings->get_MemTabState (); | |
107 | }; | |
108 | ||
109 | // Set the list of memory tabs for this view | |
110 | void | |
111 | set_MemTabState (Vector<bool>*sel) | |
112 | { | |
113 | settings->set_MemTabState (sel); | |
114 | }; | |
115 | ||
116 | // Get the list of index tabs for this view | |
117 | Vector<bool> * | |
118 | get_IndxTabState () | |
119 | { | |
120 | return settings->get_IndxTabState (); | |
121 | }; | |
122 | ||
123 | // Set the list of memory tabs for this view | |
124 | void | |
125 | set_IndxTabState (Vector<bool>*sel) | |
126 | { | |
127 | settings->set_IndxTabState (sel); | |
128 | }; | |
129 | ||
130 | // controlling the name format | |
131 | Cmd_status | |
132 | set_name_format (char *str) | |
133 | { | |
134 | return settings->set_name_format (str); | |
135 | }; | |
136 | ||
137 | void | |
138 | set_name_format (int fname_format, bool soname) | |
139 | { | |
140 | settings->set_name_format (fname_format, soname); | |
141 | }; | |
142 | ||
143 | Histable::NameFormat | |
144 | get_name_format () | |
145 | { | |
146 | return settings->name_format; | |
147 | } | |
148 | ||
149 | // processing modes: view_mode | |
150 | Cmd_status set_view_mode (char *str, bool fromRC); // from a string | |
151 | void set_view_mode (VMode mode); // from the analyzer | |
152 | ||
153 | VMode | |
154 | get_view_mode () | |
155 | { | |
156 | return settings->get_view_mode (); | |
157 | }; | |
158 | ||
159 | // handling of descendant processes | |
160 | Cmd_status set_en_desc (char *str, bool rc); // from a string | |
161 | ||
162 | bool | |
163 | check_en_desc (const char * lineage_name = NULL, const char *targname = NULL) | |
164 | { | |
165 | return settings->check_en_desc (lineage_name, targname); | |
166 | }; | |
167 | ||
168 | // Controlling the print line-limit | |
169 | char * | |
170 | set_limit (char *str, bool rc) // from a string | |
171 | { | |
172 | settings->set_limit (str, rc); | |
173 | return NULL; | |
174 | }; | |
175 | ||
176 | char * | |
177 | set_limit (int _limit) | |
178 | { | |
179 | settings->limit = _limit; | |
180 | return NULL; | |
181 | }; | |
182 | ||
183 | int | |
184 | get_limit () | |
185 | { | |
186 | return settings->limit; | |
187 | }; | |
188 | ||
189 | // Controlling the print format mode | |
190 | char * | |
191 | set_printmode (char *str) | |
192 | { | |
193 | return settings->set_printmode (str); | |
194 | }; | |
195 | ||
196 | enum PrintMode | |
197 | get_printmode () | |
198 | { | |
199 | return settings->print_mode; | |
200 | }; | |
201 | ||
202 | char | |
203 | get_printdelimiter () | |
204 | { | |
205 | return settings->print_delim; | |
206 | }; | |
207 | ||
208 | char * | |
209 | get_printmode_str () | |
210 | { | |
211 | return dbe_strdup (settings->str_printmode); | |
212 | }; | |
213 | ||
214 | // processing compiler commentary visibility bits, and other source annotation | |
215 | // controls | |
216 | Cmd_status | |
217 | proc_compcom (const char *cmd, bool isSrc, bool rc) | |
218 | { | |
219 | return settings->proc_compcom (cmd, isSrc, rc); | |
220 | }; | |
221 | ||
222 | char * | |
223 | get_str_scompcom () | |
224 | { | |
225 | return settings->str_scompcom; | |
226 | }; | |
227 | ||
228 | char * | |
229 | get_str_dcompcom () | |
230 | { | |
231 | return settings->str_dcompcom; | |
232 | }; | |
233 | ||
234 | void | |
235 | set_src_compcom (int v) | |
236 | { | |
237 | settings->src_compcom = v; | |
238 | }; | |
239 | ||
240 | int | |
241 | get_src_compcom () | |
242 | { | |
243 | return settings->src_compcom; | |
244 | }; | |
245 | ||
246 | void | |
247 | set_dis_compcom (int v) | |
248 | { | |
249 | settings->dis_compcom = v; | |
250 | }; | |
251 | ||
252 | int | |
253 | get_dis_compcom () | |
254 | { | |
255 | return settings->dis_compcom; | |
256 | }; | |
257 | ||
258 | void | |
259 | set_cmpline_visible (bool vis) | |
260 | { | |
261 | settings->set_cmpline_visible (vis); | |
262 | } | |
263 | ||
264 | int | |
265 | get_cmpline_visible () | |
266 | { | |
267 | return settings->cmpline_visible; | |
268 | } | |
269 | ||
270 | void | |
271 | set_funcline_visible (bool vis) | |
272 | { | |
273 | settings->set_funcline_visible (vis); | |
274 | } | |
275 | ||
276 | int | |
277 | get_funcline_visible () | |
278 | { | |
279 | return settings->funcline_visible; | |
280 | } | |
281 | ||
282 | // controls for disassembly presentation | |
283 | void | |
284 | set_src_visible (int vis) | |
285 | { | |
286 | settings->set_src_visible (vis); | |
287 | } | |
288 | ||
289 | int | |
290 | get_src_visible () | |
291 | { | |
292 | return settings->src_visible; | |
293 | } | |
294 | ||
295 | void | |
296 | set_srcmetric_visible (bool vis) | |
297 | { | |
298 | settings->set_srcmetric_visible (vis); | |
299 | } | |
300 | ||
301 | bool | |
302 | get_srcmetric_visible () | |
303 | { | |
304 | return settings->srcmetric_visible; | |
305 | } | |
306 | ||
307 | void | |
308 | set_hex_visible (bool vis) | |
309 | { | |
310 | settings->set_hex_visible (vis); | |
311 | } | |
312 | ||
313 | bool | |
314 | get_hex_visible () | |
315 | { | |
316 | return settings->hex_visible; | |
317 | } | |
318 | ||
319 | // processing and accessing the threshold settings | |
320 | Cmd_status | |
321 | proc_thresh (char *cmd, bool isSrc, bool rc) | |
322 | { | |
323 | return settings->proc_thresh (cmd, isSrc, rc); | |
324 | }; | |
325 | ||
326 | void | |
327 | set_thresh_src (int v) | |
328 | { | |
329 | settings->threshold_src = v; | |
330 | }; | |
331 | ||
332 | int | |
333 | get_thresh_src () | |
334 | { | |
335 | return settings->threshold_src; | |
336 | }; | |
337 | ||
338 | void | |
339 | set_thresh_dis (int v) | |
340 | { | |
341 | settings->threshold_dis = v; | |
342 | }; | |
343 | ||
344 | int | |
345 | get_thresh_dis () | |
346 | { | |
347 | return settings->threshold_dis; | |
348 | }; | |
349 | ||
350 | // controls for the Timeline mode, stack presentation | |
351 | Cmd_status | |
352 | proc_tlmode (char *cmd, bool rc) | |
353 | { | |
354 | return settings->proc_tlmode (cmd, rc); | |
355 | }; | |
356 | ||
357 | void | |
358 | set_tlmode (int _tlmode) | |
359 | { | |
360 | settings->tlmode = _tlmode; | |
361 | }; | |
362 | ||
363 | int | |
364 | get_tlmode () | |
365 | { | |
366 | return settings->tlmode; | |
367 | }; | |
368 | ||
369 | void | |
370 | set_stack_align (int _stack_align) | |
371 | { | |
372 | settings->stack_align = _stack_align; | |
373 | }; | |
374 | ||
375 | int | |
376 | get_stack_align () | |
377 | { | |
378 | return settings->stack_align; | |
379 | }; | |
380 | ||
381 | void | |
382 | set_stack_depth (int _stack_depth) | |
383 | { | |
384 | settings->stack_depth = _stack_depth; | |
385 | }; | |
386 | ||
387 | int | |
388 | get_stack_depth () | |
389 | { | |
390 | return settings->stack_depth; | |
391 | }; | |
392 | ||
393 | // Controls for which data is shown in Timeline | |
394 | Cmd_status | |
395 | proc_tldata (char *cmd, bool rc) | |
396 | { | |
397 | return settings->proc_tldata (cmd, rc); | |
398 | }; | |
399 | ||
400 | void | |
401 | set_tldata (const char* tldata_cmd) | |
402 | { | |
403 | settings->set_tldata (tldata_cmd); | |
404 | }; | |
405 | ||
406 | char* | |
407 | get_tldata () | |
408 | { | |
409 | return settings->get_tldata (); | |
410 | }; | |
411 | ||
412 | // settings controlling the expand/collapse of functions within each LoadObject | |
413 | enum LibExpand get_lo_expand (int idx); | |
414 | ||
415 | // set_lo_expand -- returns true if any change | |
416 | bool set_lo_expand (int idx, enum LibExpand how); | |
417 | ||
418 | // set_libexpand -- returns true if any change | |
419 | bool set_libexpand (char *liblist, enum LibExpand flag); | |
420 | void update_lo_expands (); | |
421 | bool set_libdefaults (); | |
422 | void reset (); | |
423 | void reset_data (bool all); | |
424 | ||
425 | char * | |
426 | get_error_msg () | |
427 | { | |
428 | return error_msg; | |
429 | }; | |
430 | ||
431 | void | |
432 | clear_error_msg () | |
433 | { | |
434 | error_msg = NULL; | |
435 | }; | |
436 | ||
437 | char * | |
438 | get_warning_msg () | |
439 | { | |
440 | return warning_msg; | |
441 | }; | |
442 | ||
443 | void | |
444 | clear_warning_msg () | |
445 | { | |
446 | warning_msg = NULL; | |
447 | }; | |
448 | char *get_processor_msg (int type); | |
449 | ||
450 | // methods controlling the metric list | |
451 | BaseMetric *register_metric_expr (BaseMetric::Type type, char *aux, char *expr_spec); | |
452 | Vector<BaseMetric*> *get_all_reg_metrics (); | |
453 | void reset_metric_list (MetricList *mlist, int cmp_mode); | |
454 | ||
455 | // Get the various metric master lists | |
456 | MetricList *get_metric_ref (MetricType mtype); | |
457 | ||
458 | // Get the various current metric lists | |
459 | MetricList *get_metric_list (int dsptype, int subtype); | |
460 | MetricList *get_metric_list (MetricType mtype); | |
461 | MetricList *get_metric_list (MetricType mtype, bool compare, int gr_num); | |
462 | MetricList *get_compare_mlist (MetricList *met_list, int grInd); | |
463 | ||
464 | // Set the metric list, from a string specification | |
465 | char *setMetrics (char *metricspec, bool fromRcFile); | |
466 | ||
467 | // Set the sort metric, from its name | |
468 | char *setSort (char *sortname, MetricType mtype, bool fromRcFile); | |
469 | ||
470 | // Set the sort metric, from its visible index (Analyzer) | |
471 | void setSort (int visindex, MetricType mtype, bool reverse); | |
472 | ||
473 | // Resort any cached data, after changing sort | |
474 | void resortData (MetricType mtype); | |
475 | ||
476 | // Get the sort metric | |
477 | char *getSort (MetricType mtype); | |
478 | char *getSortCmd (MetricType mtype); | |
479 | ||
480 | // reset the metrics | |
481 | void reset_metrics (); | |
482 | bool comparingExperiments (); | |
483 | ||
484 | int | |
485 | get_compare_mode () | |
486 | { | |
487 | return settings->compare_mode; | |
488 | }; | |
489 | ||
490 | void | |
491 | reset_compare_mode (int mode) | |
492 | { | |
493 | settings->compare_mode = mode; | |
494 | }; | |
495 | ||
496 | void set_compare_mode (int mode); // modifies the global MET_* arrays | |
497 | void add_compare_metrics (MetricList *mlist); | |
498 | void remove_compare_metrics (MetricList *mlist); | |
499 | Histable *get_compare_obj (Histable *obj); | |
500 | ||
501 | // method for printing the instruction-frequency report | |
502 | void ifreq (FILE *); | |
503 | ||
504 | // methods controlling the experiment list | |
505 | void add_experiment (int index, bool enabled); | |
506 | void add_subexperiment (int index, bool enabled); | |
507 | void add_experiment_epilogue (); | |
508 | void drop_experiment (int index); | |
509 | bool get_exp_enable (int n); | |
510 | void set_exp_enable (int n, bool e); | |
511 | ||
512 | // method for new-style filtering | |
513 | char *set_filter (const char *filter_spec); | |
514 | char *get_filter (void); | |
515 | char *get_advanced_filter (); | |
516 | void backtrack_filter (); | |
517 | void update_advanced_filter (); | |
518 | FilterExp *get_FilterExp (Experiment *exp); | |
519 | ||
520 | Expression * | |
521 | get_filter_expr () | |
522 | { | |
523 | return cur_filter_expr; | |
524 | }; | |
525 | ||
526 | // methods controlling old-style filtering | |
527 | Vector<FilterNumeric*> *get_all_filters (int nexp); | |
528 | FilterNumeric *get_FilterNumeric (int nexp, int idx); | |
529 | bool set_pattern (int n, Vector<char *> *pattern_str, bool *error); | |
530 | bool set_pattern (int m, char *pattern); | |
531 | ||
532 | // Data processing objects | |
533 | PathTree * | |
534 | get_path_tree () | |
535 | { | |
536 | return ptree; | |
537 | }; | |
538 | ||
539 | DataSpace * | |
540 | get_data_space () | |
541 | { | |
542 | return dspace; | |
543 | }; | |
544 | ||
545 | IOActivity * | |
546 | get_io_space () | |
547 | { | |
548 | return iospace; | |
549 | }; | |
550 | ||
551 | HeapActivity * | |
552 | get_heap_space () | |
553 | { | |
554 | return heapspace; | |
555 | }; | |
556 | Hist_data *get_data (MetricList *mlist, Histable *selObj, int type, int subtype); | |
557 | int get_sel_ind (Histable *selObj, int type, int subtype); | |
558 | ||
559 | // Return histogram data for the specified arguments. | |
560 | Hist_data *get_hist_data (MetricList *mlist, Histable::Type type, | |
561 | int subtype, // used for memory objects only | |
562 | Hist_data::Mode mode, | |
563 | Vector<Histable*> *objs = NULL, | |
564 | Histable *context = NULL, | |
565 | Vector<Histable*> *sel_objs = NULL, | |
566 | PathTree::PtreeComputeOption flag = PathTree::COMPUTEOPT_NONE | |
567 | ); | |
568 | Hist_data *get_hist_data (MetricList *mlist, Histable::Type type, | |
569 | int subtype, // used for memory objects only | |
570 | Hist_data::Mode mode, Histable *obj, | |
571 | Histable *context = NULL, | |
572 | Vector<Histable*> *sel_objs = NULL, | |
573 | PathTree::PtreeComputeOption flag = PathTree::COMPUTEOPT_NONE | |
574 | ); | |
575 | CStack_data *get_cstack_data (MetricList *); | |
576 | Stats_data *get_stats_data (int index); | |
577 | Ovw_data *get_ovw_data (int index); | |
578 | ||
579 | char *names_src[3]; // names for anno-src | |
580 | char *names_dis[3]; // names for anno-dis | |
581 | ||
582 | // Get filtered packets. Ordering is NOT guaranteed to be | |
583 | // stable between calls; DataView indexes are not persistent - | |
584 | // use underlying DataDescriptor ids if you don't consume data right away. | |
585 | // Parameters: idx==exp_id, data_id==kind==ProfData_type | |
586 | DataView *get_filtered_events (int idx, int data_id); | |
587 | DataView *get_filtered_events (int idx, int data_id, | |
588 | const int sortprops[], int sortprop_count); | |
589 | ||
590 | // SORT is not used for PathTree. | |
591 | // PathTree reads data once and discards. It doesn't | |
592 | // depend on the indices so sort can be performed w/o recomputing pathtree. | |
593 | // Timeline is the primary consumer of sort(), however Races also need to sort. | |
594 | // | |
595 | // YM: I can't remember the context for the following note, but | |
596 | // In case I need it when we refactor more TBR stuff, here it is: | |
597 | // base metrics like USER_CPU are known,(but we should/should not?) | |
598 | // explicitly set DATA_CLOCK as a property/attribute? | |
599 | bool adjust_filter (Experiment *exp); | |
600 | ||
601 | // Generated report data | |
602 | Hist_data *func_data; // function list data | |
603 | Hist_data *line_data; // hot line list data | |
604 | Hist_data *pc_data; // hot PC list data | |
605 | Hist_data *src_data; // annotated source data | |
606 | Hist_data *dis_data; // annotated disasm data | |
607 | Hist_data *fitem_data; // func item for callers/callees | |
608 | Hist_data *callers; // callers data | |
609 | Hist_data *callees; // callees data | |
610 | Hist_data *dobj_data; // data object list data | |
611 | Hist_data *dlay_data; // data layout data | |
612 | Hist_data *iofile_data; // io data aggregated by file name | |
613 | Hist_data *iovfd_data; // io data aggregated by virtual fd | |
614 | Hist_data *iocs_data; // io data aggregated by call stack | |
615 | Hist_data *heapcs_data; // heap data aggregated by call stack | |
616 | Vector<Hist_data*> *indx_data; // index object data | |
617 | Vector<int> *lobjectsNoJava; // List of indices into LoadObjects excluding java classes | |
618 | ||
619 | // memory object data -- create MemorySpace, if needed | |
620 | MemorySpace *getMemorySpace (int subtype); | |
621 | char *get_mobj_name (int subtype); | |
622 | void addIndexSpace (int type); | |
623 | Hist_data *get_indxobj_data (int subtype); | |
624 | void set_indxobj_sel (int subtype, int sel_ind); | |
625 | Histable *get_indxobj_sel (int subtype); | |
626 | void set_obj_sel_io (int type, long sel_ind); | |
627 | Histable *set_sel_obj (Histable *obj); | |
628 | Histable *get_sel_obj (Histable::Type type); | |
629 | Histable *get_sel_obj_io (uint64_t id, Histable::Type type); | |
630 | Histable *get_sel_obj_heap (uint64_t id); | |
631 | Histable *sel_obj; // current selected obj | |
632 | Histable *sel_dobj; // current selected data obj | |
633 | Histable *sel_binctx; // current binary context | |
634 | Vector<Histable*> *sel_idxobj; // selected index objects | |
635 | char *error_msg; // error message | |
636 | char *warning_msg; // warning message | |
637 | Vector<int> *marks; // flagged as important for anno src/dis | |
638 | Vector<int_pair_t> *marks2dsrc; | |
639 | Vector<int_pair_t> *marks2dsrc_inc; | |
640 | Vector<int_pair_t> *marks2ddis; | |
641 | Vector<int_pair_t> *marks2ddis_inc; | |
642 | ||
643 | void dump_nodes (FILE *); // dump out the pathtree nodes | |
644 | void dump_profile (FILE *); // dump out the clock profiling events | |
645 | void dump_sync (FILE *); // dump out the synctrace events | |
646 | void dump_iotrace (FILE *); // dump out the IO trace events | |
647 | void dump_hwc (FILE *); // dump out the HWC Profiling events | |
648 | void dump_heap (FILE *); // dump out the heap trace events | |
649 | void dump_gc_events (FILE *); // dump out the Java garbage collector events | |
650 | ||
651 | int vindex; // index of this view -- set by Analyzer | |
652 | bool func_scope; | |
653 | ||
654 | bool | |
655 | get_func_scope () | |
656 | { | |
657 | return func_scope; | |
658 | }; | |
659 | ||
660 | void | |
661 | set_func_scope (bool scope_only) | |
662 | { | |
663 | func_scope = scope_only; | |
664 | }; | |
665 | ||
666 | // value set T if filtering is active, i.e., some packets were dropped | |
667 | bool filter_active; | |
668 | ||
669 | bool | |
670 | get_filter_active () | |
671 | { | |
672 | return filter_active; | |
673 | }; | |
674 | ||
675 | DerivedMetrics * | |
676 | get_derived_metrics () | |
677 | { | |
678 | return derived_metrics; | |
679 | } | |
680 | ||
681 | // Internal time (time means change) | |
682 | int | |
683 | getPhaseIdx () | |
684 | { | |
685 | return phaseIdx; | |
686 | } | |
687 | ||
688 | enum DbeView_status | |
689 | { | |
690 | DBEVIEW_SUCCESS = 0, | |
691 | DBEVIEW_NO_DATA, | |
692 | DBEVIEW_IO_ERROR, | |
693 | DBEVIEW_BAD_DATA, | |
694 | DBEVIEW_BAD_SYMBOL_DATA, | |
695 | DBEVIEW_NO_SEL_OBJ | |
696 | }; | |
697 | static char *status_str (DbeView_status status); | |
698 | ||
699 | bool | |
700 | isOmpDisMode () | |
701 | { | |
702 | return ompDisMode; | |
703 | } | |
704 | ||
705 | void | |
706 | setOmpDisMode () | |
707 | { | |
708 | ompDisMode = true; | |
709 | } | |
710 | ||
711 | void | |
712 | resetOmpDisMode () | |
713 | { | |
714 | ompDisMode = false; | |
715 | } | |
716 | ||
717 | bool | |
718 | isShowHideChanged () | |
719 | { | |
720 | return showHideChanged; | |
721 | } | |
722 | ||
723 | void | |
724 | setShowHideChanged () | |
725 | { | |
726 | showHideChanged = true; | |
727 | } | |
728 | ||
729 | void | |
730 | resetShowHideChanged () | |
731 | { | |
732 | showHideChanged = false; | |
733 | } | |
734 | ||
735 | bool | |
736 | isNewViewMode () | |
737 | { | |
738 | return newViewMode; | |
739 | } | |
740 | ||
741 | void | |
742 | setNewViewMode () | |
743 | { | |
744 | newViewMode = true; | |
745 | } | |
746 | ||
747 | void | |
748 | resetNewViewMode () | |
749 | { | |
750 | newViewMode = false; | |
751 | } | |
752 | ||
753 | bool | |
754 | isFilterHideMode () | |
755 | { | |
756 | return filterHideMode; | |
757 | } | |
758 | ||
759 | void | |
760 | setFilterHideMode () | |
761 | { | |
762 | filterHideMode = true; | |
763 | } | |
764 | ||
765 | void | |
766 | resetFilterHideMode () | |
767 | { | |
768 | filterHideMode = false; | |
769 | } | |
770 | ||
771 | bool | |
772 | isShowAll () | |
773 | { | |
774 | return showAll; | |
775 | } | |
776 | ||
777 | void | |
778 | setShowAll () | |
779 | { | |
780 | showAll = true; | |
781 | } | |
782 | ||
783 | void | |
784 | resetShowAll () | |
785 | { | |
786 | showAll = false; | |
787 | } | |
788 | void resetAndConstructShowHideStacks (); | |
789 | ||
790 | private: | |
791 | void init (); | |
792 | Metric *get_compare_metric (Metric *mtr, int groupNum); | |
793 | ||
794 | // methods controlling old-style filtering | |
795 | FilterSet *get_filter_set (int n); | |
796 | ||
797 | void purge_events (int n = -1); | |
798 | ||
799 | char *cur_filter_str; | |
800 | char *prev_filter_str; | |
801 | Expression *cur_filter_expr; | |
802 | bool noParFilter; | |
803 | ||
804 | // MemorySpace's -- added when a request is made; for now, never dropped | |
805 | Vector<MemorySpace*> *memspaces; | |
806 | MemorySpace *addMemorySpace (int mtype); | |
807 | ||
808 | Vector<FilterSet*> *filters; | |
809 | Vector<enum LibExpand> *lo_expands; | |
810 | Vector<BaseMetric*> *reg_metrics; // vector of registered metrics | |
811 | Vector<MetricList*> *metrics_lists; // metrics list of MET_NORMAL, MET_CALL... | |
812 | // note: includes compare metrics | |
813 | Vector<MetricList*> *metrics_ref_lists; | |
814 | DerivedMetrics *derived_metrics; // vector of derived metrics | |
815 | ||
816 | DataSpace *dspace; | |
817 | PathTree *ptree; | |
818 | Vector<PathTree *> *indxspaces; | |
819 | IOActivity *iospace; | |
820 | HeapActivity *heapspace; | |
821 | int phaseIdx; | |
822 | bool ompDisMode; | |
823 | bool filterHideMode; | |
824 | bool showAll; | |
825 | bool showHideChanged; | |
826 | bool newViewMode; | |
827 | ||
828 | // Filtered events | |
829 | Vector<Vector<DataView*>*> *dataViews; //outer idx is exp_id, inner is data_id | |
830 | Settings *settings; | |
831 | ||
832 | Application *app; | |
833 | Function *convert_line_to_func (DbeLine *dbeLine); | |
834 | DbeInstr *convert_line_to_instr (DbeLine *dbeLine); | |
835 | DbeInstr *convert_func_to_instr (Function *func); | |
836 | DbeInstr *lastSelInstr; | |
837 | Function *lastSelFunc; | |
838 | void constructShowHideStack (DataDescriptor* dDscr, Experiment *exp); | |
839 | void resetAndConstructShowHideStack (Experiment *exp); | |
840 | }; | |
841 | ||
842 | #endif /* _DBEVIEW_H */ |