gprofng/src/DbeView.h

   1 /* Copyright (C) 2021 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 /*
  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 */