Update year range in copyright notice of binutils files

[binutils-gdb.git] / gprofng / src / Dbe.cc

/* Copyright (C) 2021-2024 Free Software Foundation, Inc.
   Contributed by Oracle.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "config.h"
#include <errno.h>
#include <sys/types.h> // open, chmod
#include <signal.h>
#include <fcntl.h>     // open
#include <strings.h>
#include <unistd.h>

#include "util.h"
#include "Histable.h"
#include "DbeSession.h"
#include "DbeView.h"
#include "BaseMetric.h"
#include "CallStack.h"
#include "collctrl.h"
#include "Command.h"
#include "Dbe.h"
#include "DbeApplication.h"
#include "DefaultMap.h"
#include "LoadObject.h"
#include "Experiment.h"
#include "IndexObject.h"
#include "IOActivity.h"
#include "PreviewExp.h"
#include "Function.h"
#include "Hist_data.h"
#include "MetricList.h"
#include "Module.h"
#include "DataSpace.h"
#include "MemorySpace.h"
#include "DataObject.h"
#include "MemObject.h"
#include "Filter.h"
#include "FilterSet.h"
#include "FilterExp.h"
#include "Sample.h"
#include "Print.h"
#include "StringBuilder.h"
#include "dbe_types.h"
#include "ExpGroup.h"
#include "vec.h"
#include "UserLabel.h"
#include "DbeFile.h"
#include "PathTree.h"

// Data structures for managing the collector control info for Collection GUI
static Coll_Ctrl *col_ctr = NULL;

template<> VecType Vector<int>::type ()
{
  return VEC_INTEGER;
}

template<> VecType Vector<unsigned>::type ()
{
  return VEC_INTEGER;
}

template<> VecType Vector<char>::type ()
{
  return VEC_CHAR;
}

template<> VecType Vector<bool>::type ()
{
  return VEC_BOOL;
}

template<> VecType Vector<double>::type ()
{
  return VEC_DOUBLE;
}

template<> VecType Vector<long long>::type ()
{
  return VEC_LLONG;
}

template<> VecType Vector<uint64_t>::type ()
{
  return VEC_LLONG;
}

template<> VecType Vector<void*>::type ()
{
  return VEC_VOIDARR;
}

template<> VecType Vector<char*>::type ()
{
  return VEC_STRING;
}

template<> VecType Vector<Vector<int>*>::type ()
{
  return VEC_INTARR;
}

template<> VecType Vector<Vector<char*>*>::type ()
{
  return VEC_STRINGARR;
}

template<> VecType Vector<Vector<long long>*>::type ()
{
  return VEC_LLONGARR;
}

// gcc won't instantiate Vector<unsigned>::type() without it
Vector<unsigned> __dummy_unsigned_vector;

#define CASE_S(x)   case x: return #x
static const char *
dsp_type_to_string (int t)
{
  switch (t)
    {
      CASE_S (DSP_FUNCTION);
      CASE_S (DSP_LINE);
      CASE_S (DSP_PC);
      CASE_S (DSP_SOURCE);
      CASE_S (DSP_DISASM);
      CASE_S (DSP_SELF);
      CASE_S (DSP_CALLER);
      CASE_S (DSP_CALLEE);
      CASE_S (DSP_CALLTREE);
      CASE_S (DSP_TIMELINE);
      CASE_S (DSP_STATIS);
      CASE_S (DSP_EXP);
      CASE_S (DSP_LEAKLIST);
      CASE_S (DSP_MEMOBJ);
      CASE_S (DSP_DATAOBJ);
      CASE_S (DSP_DLAYOUT);
      CASE_S (DSP_SRC_FILE);
      CASE_S (DSP_IFREQ);
      CASE_S (DSP_RACES);
      CASE_S (DSP_INDXOBJ);
      CASE_S (DSP_DUALSOURCE);
      CASE_S (DSP_SOURCE_DISASM);
      CASE_S (DSP_DEADLOCKS);
      CASE_S (DSP_SOURCE_V2);
      CASE_S (DSP_DISASM_V2);
      CASE_S (DSP_IOACTIVITY);
      CASE_S (DSP_OVERVIEW);
      CASE_S (DSP_IOCALLSTACK);
      CASE_S (DSP_HEAPCALLSTACK);
      CASE_S (DSP_SAMPLE);
    default:
      break;
    }
  return NTXT ("ERROR");
}

enum
{
  COMPARE_BIT       = 1 << 8,
  MTYPE_MASK        = (1 << 8) - 1,
  GROUP_ID_SHIFT    = 16
};

static DbeView *
getDbeView (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  return dbev;
}


Vector<char*> *
dbeGetInitMessages ()
{
  // If any comments from the .rc files, send them to the GUI
  Emsg *msg = theDbeApplication->fetch_comments ();
  int size = 0;
  while (msg != NULL)
    {
      size++;
      msg = msg->next;
    }

  // Initialize Java String array
  Vector<char*> *list = new Vector<char*>(size);
  msg = theDbeApplication->fetch_comments ();
  size = 0;
  int i = 0;
  while (msg != NULL)
    {
      char *str = msg->get_msg ();
      list->store (i, dbe_strdup (str));
      i++;
      msg = msg->next;
    }

  // now delete the comments
  theDbeApplication->delete_comments ();
  return list;
}

Vector<char*> *
dbeGetExpPreview (int /*dbevindex*/, char *exp_name)
{
  PreviewExp *preview = new PreviewExp ();
  preview->experiment_open (exp_name);
  preview->open_epilogue ();

  // Initialize Java String array
  Vector<char*> *info = preview->preview_info ();
  int size = info->size ();
  Vector<char*> *list = new Vector<char*>(size);

  // Get experiment names
  for (int i = 0; i < size; i++)
    {
      char *str = info->fetch (i);
      if (str == NULL)
        str = GTXT ("N/A");
      list->store (i, dbe_strdup (str));
    }
  delete info;
  delete preview;
  return list;
}

char *
dbeGetExpParams (int /*dbevindex*/, char *exp_name)
{
  PreviewExp *preview = new PreviewExp ();
  preview->experiment_open (exp_name);

  // Initialize Java String array
  char *arg_list = dbe_strdup (preview->getArgList ());
  delete preview;
  return arg_list;
}

/**
 * Gets File Attributes according to the specified format
 * Supported formats:
 * "/bin/ls -dl " - see 'man ls' for details
 * @param filename
 * @param format
 * @return char * attributes
 */
char *
dbeGetFileAttributes (const char *filename, const char *format)
{
  if (format != NULL)
    {
      if (!strcmp (format, NTXT ("/bin/ls -dl ")))
        {
          // A kind of "/bin/ls -dl " simulation
          dbe_stat_t sbuf;
          sbuf.st_mode = 0;
          dbe_stat (filename, &sbuf);
          if (S_IREAD & sbuf.st_mode)
            { // Readable
              if (S_ISDIR (sbuf.st_mode) != 0)
                return dbe_sprintf (NTXT ("%s %s\n"), NTXT ("drwxrwxr-x"), filename);
              else if (S_ISREG (sbuf.st_mode) != 0)
                return dbe_sprintf (NTXT ("%s %s\n"), NTXT ("-rwxrwxr-x"), filename);
            }
        }
    }
  return dbe_strdup (NTXT (""));
}

/**
 * Gets list of files for specified directory according to the specified format
 * Supported formats:
 * "/bin/ls -a" - see 'man ls' for details
 * "/bin/ls -aF" - see 'man ls' for details
 * @param dirname
 * @param format
 * @return char * files
 */
char *
dbeGetFiles (const char *dirname, const char *format)
{
  if (format != NULL)
    return dbe_read_dir (dirname, format);
  return dbe_strdup (NTXT (""));
}

/**
 * Creates the directory named by this full path name, including any
 * necessary but nonexistent parent directories.
 * @param dirname
 * @return result
 */
char *
dbeCreateDirectories (const char *dirname)
{
  if (dirname != NULL)
    {
      char *res = dbe_create_directories (dirname);
      if (res != NULL)
        return res;
    }
  return dbe_strdup (NTXT (""));
}

/**
 * Deletes the file or the directory named by the specified path name.
 * If this pathname denotes a directory, then the directory must be empty in order to be deleted.
 * @param const char *pathname
 * @return int result
 */
char *
dbeDeleteFile (const char *pathname)
{
  // return unlink(pathname);
  if (pathname != NULL)
    {
      char *res = dbe_delete_file (pathname);
      if (res != NULL)
        return res;
    }
  return dbe_strdup (NTXT (""));
}

/**
 * Reads the file named by the specified path name.
 * Temporary limitation: file should be "text only" and its size should be less than the 1 MB limit.
 * If the operation was successful, the contents is in the first element, and second element is NULL.
 * If the operation failed, then first element is NULL, and second element contains the error message.
 * @param const char *pathname
 * @return Vector<char*> *result
 */
Vector<char*> *
dbeReadFile (const char *pathname)
{
  Vector<char*> *result = new Vector<char*>(2);
  int limit = 1024 * 1024; // Temporary limit: 1 MB
  char * contents = (char *) malloc (limit);
  StringBuilder sb;
  if (NULL == contents)
    {
      sb.sprintf (NTXT ("\nError: Cannot allocate %d bytes\n"), limit);
      result->store (0, NULL);
      result->store (1, sb.toString ()); // failure
      return result;
    }
  int fd = open (pathname, O_RDONLY);
  if (fd >= 0)
    {
      int64_t bytes = read_from_file (fd, contents, limit);
      close (fd);
      if (bytes >= limit)
        {
          sb.sprintf (NTXT ("\nError: file size is greater than the limit (%d bytes)\n"), limit);
          result->store (0, NULL);
          result->store (1, sb.toString ()); // failure
        }
      else
        {
          contents[bytes] = '\0'; // add string terminator
          result->store (0, contents);
          result->store (1, NULL); // success
        }
    }
  else
    {
      sb.sprintf (NTXT ("\nError: Cannot open file %s\n"), pathname);
      result->store (0, NULL);
      result->store (1, sb.toString ()); // failure
      free (contents);
    }
  return result;
}

/**
 * Writes the file named by the specified path name.
 * Temporary limitation: file should be "text only" and its size should be less than the 1 MB limit.
 * If the operation failed, then -1 is returned.
 * @param const char *pathname
 * @return int result  (written bytes)
 */
int
dbeWriteFile (const char *pathname, const char *contents)
{
  int result = -1; // error
  size_t len = 0;
  if (NULL != contents)
    len = strlen (contents);
  size_t limit = 1024 * 1024; // Temporary limit: 1 MB
  if (len > limit) return result;
  unlink (pathname);
  mode_t mode = S_IRUSR | S_IWUSR;
  int fd = open (pathname, O_WRONLY | O_CREAT | O_TRUNC, mode);
  if (fd >= 0)
    {  // replace file contents
      chmod (pathname, /*S_IRUSR || S_IWUSR*/ 0600); // rw for owner only
      ssize_t bytes = 0;
      if (len > 0)
        bytes = write (fd, contents, len);
      close (fd);
      result = (int) bytes;
    }
  return result;
}

/**
 * Gets list of running processes according to the specified format
 * Supported formats:
 * "/bin/ps -ef" - see 'man ps' for details
 * @param format
 * @return char * processes
 */
char *
dbeGetRunningProcesses (const char *format)
{
  if (format != NULL)
    return dbe_get_processes (format);
  return dbe_strdup (NTXT (""));
}

//
// Open experiment
//
char *
dbeOpenExperimentList (int /* dbevindex */, Vector<Vector<char*>*> *groups,
                       bool sessionRestart)
{
  if (sessionRestart)
    dbeSession->reset ();
  char *errstr;
  // Open experiments
  try
    {
      errstr = dbeSession->setExperimentsGroups (groups);
    }
  catch (ExperimentLoadCancelException *)
    {
      errstr = dbe_strdup (NTXT ("Experiment Load Cancelled"));
    }
  return errstr;
}

//
// Drop experiments
//
char *
dbeDropExperiment (int /* dbevindex */, Vector<int> *drop_index)
{
  for (int i = drop_index->size () - 1; i >= 0; i--)
    {
      char *ret = dbeSession->drop_experiment (drop_index->fetch (i));
      if (ret != NULL)
          return ret;
    }
  return NULL;
}

/**
 * Read .er.rc file from the specified location
 * @param path
 * @return
 */
char *
dbeReadRCFile (int dbevindex, char* path)
{
  DbeView *dbev = getDbeView (dbevindex);
  char *err_msg = dbev->get_settings ()->read_rc (path);
  return err_msg;
}

char *
dbeSetExperimentsGroups (Vector<Vector<char*>*> *groups)
{
  int cmp_mode = dbeSession->get_settings ()->get_compare_mode ();
  if (groups->size () < 2)
    cmp_mode = CMP_DISABLE;
  else if (cmp_mode == CMP_DISABLE)
    cmp_mode = CMP_ENABLE;
  for (int i = 0;; i++)
    {
      DbeView *dbev = dbeSession->getView (i);
      if (dbev == NULL)
        break;
      dbev->get_settings ()->set_compare_mode (cmp_mode);
    }
  char *err_msg = dbeSession->setExperimentsGroups (groups);

  // automatically load machine model if applicable
  dbeDetectLoadMachineModel (0);
  return err_msg;
}

Vector<Vector<char*>*> *
dbeGetExperimensGroups ()
{
  Vector<Vector<char*>*> *grops = dbeSession->getExperimensGroups ();
  return grops;
}

Vector<int> *
dbeGetFounderExpId (Vector<int> *expIds)
{
  Vector<int> *ret = new Vector<int>(expIds->size ());
  for (int i = 0; i < expIds->size (); i++)
    {
      int expId = expIds->fetch (i);
      Experiment *exp = dbeSession->get_exp (expId);
      if (exp != NULL)
        {
          int founderExpId = exp->getBaseFounder ()->getExpIdx ();
          ret->store (i, founderExpId);
        }
      else
        ret->store (i, -1);
    }
  return ret;
}

Vector<int> *
dbeGetUserExpId (Vector<int> *expIds)
{
  // returns "User Visible" ids used for EXPID filters and timeline processes
  Vector<int> *ret = new Vector<int>(expIds->size ());
  for (int i = 0; i < expIds->size (); i++)
    {
      int expId = expIds->fetch (i);
      Experiment *exp = dbeSession->get_exp (expId);
      if (exp != NULL)
        {
          int userExpId = exp->getUserExpId ();
          ret->store (i, userExpId);
        }
      else
        ret->store (i, -1);
    }
  return ret;
}

//
// Get experiment groupid
//
Vector<int> *
dbeGetExpGroupId (Vector<int> *expIds)
{
  Vector<int> *ret = new Vector<int>(expIds->size ());
  for (int i = 0; i < expIds->size (); i++)
    {
      int expId = expIds->fetch (i);
      Experiment *exp = dbeSession->get_exp (expId);
      if (exp != NULL)
        {
          int gId = exp->groupId;
          ret->store (i, gId);
        }
      else
        ret->store (i, -1);
    }
  return ret;
}

Vector<char*> *
dbeGetExpsProperty (const char *prop_name)
{
  long nexps = dbeSession->nexps ();
  if (prop_name == NULL || nexps == 0)
    return NULL;
  Vector<char*> *list = new Vector<char*>(nexps);
  StringBuilder sb;
  int empty = 1;
  int prop = 99;
  if (strcasecmp (prop_name, NTXT ("ERRORS")) == 0)
    prop = 1;
  else if (strcasecmp (prop_name, NTXT ("WARNINGS")) == 0)
    prop = 2;
  if (prop < 3)
    {
      for (long i = 0; i < nexps; i++)
        {
          Experiment *exp = dbeSession->get_exp (i);
          char *nm = exp->get_expt_name ();
          sb.setLength (0);
          for (Emsg *emsg = (prop == 1) ? exp->fetch_errors () : exp->fetch_warnings ();
                  emsg; emsg = emsg->next)
            sb.appendf (NTXT ("%s: %s\n"), STR (nm), STR (emsg->get_msg ()));
          char *s = NULL;
          if (sb.length () > 0)
            {
              s = sb.toString ();
              empty = 0;
            }
          list->append (s);
        }
    }
  if (empty)
    {
      delete list;
      list = NULL;
    }
  return list;
}

//
// Get experiment names
//
Vector<char*> *
dbeGetExpName (int /*dbevindex*/)
{
  int size = dbeSession->nexps ();
  if (size == 0)
    return NULL;
  // Initialize Java String array
  Vector<char*> *list = new Vector<char*>(size);

  // Get experiment names
  for (int i = 0; i < size; i++)
    {
      Experiment *texp = dbeSession->get_exp (i);
      char *buf = dbe_sprintf (NTXT ("%s [%s]"), texp->get_expt_name (),
                               texp->utargname != NULL ? texp->utargname : GTXT ("(unknown)"));
      list->store (i, buf);
    }
  return list;
}

//
// Get experiment state
//
Vector<int> *
dbeGetExpState (int /* dbevindex */)
{
  int size = dbeSession->nexps ();
  if (size == 0)
    return NULL;
  // Initialize Java array
  Vector<int> *state = new Vector<int>(size);

  // Get experiment state
  for (int i = 0; i < size; i++)
    {
      Experiment *exp = dbeSession->get_exp (i);
      int set = EXP_SUCCESS;
      if (exp->get_status () == Experiment::FAILURE)
        set |= EXP_FAILURE;
      if (exp->get_status () == Experiment::INCOMPLETE)
        set |= EXP_INCOMPLETE;
      if (exp->broken)
        set |= EXP_BROKEN;
      if (exp->obsolete)
        set |= EXP_OBSOLETE;
      state->store (i, set);
    }
  return state;
}

//
// Get enabled experiment indices
//
Vector<bool> *
dbeGetExpEnable (int dbevindex)
{
  DbeView *dbev = getDbeView (dbevindex);
  int size = dbeSession->nexps ();
  if (dbev == NULL || size == 0)
    return NULL;

  // Get enabled experiment
  Vector<bool> *enable = new Vector<bool>(size);
  for (int i = 0; i < size; i++)
    {
      bool val = dbev->get_exp_enable (i) && !dbeSession->get_exp (i)->broken;
      enable->store (i, val);
    }
  return enable;
}

//
// Get enabled experiment indices
//
bool
dbeSetExpEnable (int dbevindex, Vector<bool> *enable)
{
  DbeView *dbev = getDbeView (dbevindex);
  bool ret = false;
  int size = dbeSession->nexps ();
  if (dbev == NULL || size == 0)
    return false;

  // set enable, as per input vector
  for (int i = 0; i < size; i++)
    if (!dbeSession->get_exp (i)->broken
        && dbev->get_exp_enable (i) != enable->fetch (i))
      {
        dbev->set_exp_enable (i, enable->fetch (i));
        ret = true;
      }
  return ret;
}

//
// Get experiment info
//
Vector<char*> *
dbeGetExpInfo (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  int size = dbeSession->nexps ();
  if (size == 0)
    return NULL;

  // Initialize Java String array
  Vector<char*> *list = new Vector<char*>(size * 2 + 1);

  // Get experiment names
  Vector<LoadObject*> *text_segments = dbeSession->get_text_segments ();
  char *msg = pr_load_objects (text_segments, NTXT (""));
  delete text_segments;
  list->store (0, msg);
  int k = 1;
  for (int i = 0; i < size; i++)
    {
      Experiment *exp = dbeSession->get_exp (i);
      char *msg0 = pr_mesgs (exp->fetch_notes (), NTXT (""), NTXT (""));
      char *msg1 = pr_mesgs (exp->fetch_errors (), GTXT ("No errors\n"), NTXT (""));
      char *msg2 = pr_mesgs (exp->fetch_warnings (), GTXT ("No warnings\n"), NTXT (""));
      char *msg3 = pr_mesgs (exp->fetch_comments (), NTXT (""), NTXT (""));
      char *msg4 = pr_mesgs (exp->fetch_pprocq (), NTXT (""), NTXT (""));
      msg = dbe_sprintf (NTXT ("%s%s%s%s"), msg1, msg2, msg3, msg4);
      list->store (k++, msg0);
      list->store (k++, msg);
      free (msg1);
      free (msg2);
      free (msg3);
      free (msg4);
    }
  return list;
}

bool
dbeGetViewModeEnable ()
{
  return dbeSession->has_ompavail () || dbeSession->has_java ();
}

bool
dbeGetJavaEnable ()
{
  return dbeSession->has_java ();
}

int
dbeUpdateNotes (int dbevindex, int exp_id, int type, char* text, bool handle_file)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  int size = dbeSession->nexps ();
  if (size == 0)
    return -1;
  Experiment *exp = dbeSession->get_exp (exp_id);
  return (type == 0) ? exp->save_notes (text, handle_file) : exp->delete_notes (handle_file);
}

//
// Get load object names
//
Vector<char*> *
dbeGetLoadObjectName (int /* dbevindex */)
{
  Vector<LoadObject*> *lobjs = dbeSession->get_text_segments ();
  int size = lobjs->size ();

  // Initialize Java String array
  Vector<char*> *list = new Vector<char*>(size);

  // Get load object names
  LoadObject *lo;
  int index;
  Vec_loop (LoadObject*, lobjs, index, lo)
  {
    list->store (index, dbe_strdup (lo->get_name ()));
  }
  delete lobjs;
  return list;
}

// XXX Will use later when order has to be passed too,
// Get complete List of tabs
//
Vector<void*> *
dbeGetTabList (int /* dbevindex */)
{
  //DbeView *dbev = getDbeView (dbevindex);
  //Vector<void*> *tabs = dbeSession->get_TabList();
  //return tabs;
  return NULL;
}

//
// Returns list of available tabs
//
Vector<void*> *
dbeGetTabListInfo (int dbevindex)
{
  int index;
  DispTab *dsptab;
  DbeView *dbev = getDbeView (dbevindex);

  // make sure the tabs are initialized properly
  dbev->get_settings ()->proc_tabs (theDbeApplication->rdtMode);
  Vector<DispTab*> *tabs = dbev->get_TabList ();

  // Get number of available tabs
  int size = 0;
  Vec_loop (DispTab*, tabs, index, dsptab)
  {
    if (!dsptab->available)
      continue;
    size++;
  }
  Vector<void*> *data = new Vector<void*>(2);
  Vector<int> *typelist = new Vector<int>(size);
  Vector<char*> *cmdlist = new Vector<char*>(size);
  Vector<int> *ordlist = new Vector<int>(size);

  // Build list of avaliable tabs
  int i = 0;

  Vec_loop (DispTab*, tabs, index, dsptab)
  {
    if (!dsptab->available)
      continue;
    typelist->store (i, dsptab->type);
    cmdlist->store (i, dbe_strdup (Command::get_cmd_str (dsptab->cmdtoken)));
    ordlist->store (i, dsptab->order);
    i++;
  }
  data->store (0, typelist);
  data->store (1, cmdlist);
  data->store (2, ordlist);
  return data;
}

// Return visibility state for all available tabs
//
Vector<bool> *
dbeGetTabSelectionState (int dbevindex)
{
  int index;
  DispTab *dsptab;
  DbeView *dbev = getDbeView (dbevindex);
  Vector<DispTab*> *tabs = dbev->get_TabList ();

  // Get number of available tabs
  int size = 0;
  Vec_loop (DispTab*, tabs, index, dsptab)
  {
    if (!dsptab->available)
      continue;
    size++;
  }
  Vector<bool> *states = new Vector<bool>(size);

  // Get visibility bit for all available tabs
  int i = 0;
  Vec_loop (DispTab*, tabs, index, dsptab)
  {
    if (!dsptab->available)
      continue;
    states->store (i++, dsptab->visible);
  }
  return states;
}

// Set visibility bit for a tab
void
dbeSetTabSelectionState (int dbevindex, Vector<bool> *selected)
{
  int index;
  DispTab *dsptab;
  DbeView *dbev = getDbeView (dbevindex);
  Vector<DispTab*> *tabs = dbev->get_TabList ();
  int i = 0;
  Vec_loop (DispTab*, tabs, index, dsptab)
  {
    if (!dsptab->available)
      continue;
    dsptab->visible = selected->fetch (i++);
  }
}

// Return visibility state for all available MemObj tabs
Vector<bool> *
dbeGetMemTabSelectionState (int dbevindex)
{
  int index;
  bool dsptab;
  DbeView *dbev = getDbeView (dbevindex);
  Vector<bool> *memtabs = dbev->get_MemTabState ();

  // set the output vector
  int size = memtabs->size ();
  Vector<bool> *states = new Vector<bool>(size);

  // Get visibility bit for all available tabs
  int i = 0;
  Vec_loop (bool, memtabs, index, dsptab)
  {
    states->store (i++, dsptab);
  }
  return states;
}

// Set visibility bit for a memory tab
//
void
dbeSetMemTabSelectionState (int dbevindex, Vector<bool> *selected)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_MemTabState (selected);
}

// Return visibility state for all available index tabs
Vector<bool> *
dbeGetIndxTabSelectionState (int dbevindex)
{
  int index;
  bool dsptab;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<bool> *indxtabs = dbev->get_IndxTabState ();

  // set the output vector
  int size = indxtabs->size ();
  Vector<bool> *states = new Vector<bool>(size);

  // Get visibility bit for all available tabs
  int i = 0;
  Vec_loop (bool, indxtabs, index, dsptab)
  {
    states->store (i++, dsptab);
  }
  return states;
}

// Set visibility bit for a index tab
void
dbeSetIndxTabSelectionState (int dbevindex, Vector<bool> *selected)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_IndxTabState (selected);
}

//
// Get search path
//
Vector<char*> *
dbeGetSearchPath (int /*dbevindex*/)
{
  Vector<char*> *path = dbeSession->get_search_path ();
  int size = path->size ();
  Vector<char*> *list = new Vector<char*>(size);
  int index;
  char *name;
  Vec_loop (char*, path, index, name)
  {
    list->store (index, dbe_strdup (name));
  }
  return list;
}

//
// Set search path
//
void
dbeSetSearchPath (int /*dbevindex*/, Vector<char*> *path)
{
  dbeSession->set_search_path (path, true);
  return;
}

//
// Get pathmaps
//
Vector<void*> *
dbeGetPathmaps (int /*dbevindex*/)
{
  int index;
  pathmap_t *pthmap;
  Vector<pathmap_t*> *path = dbeSession->get_pathmaps ();
  int size = path->size ();
  Vector<void*> *data = new Vector<void*>(2);
  Vector<char*> *oldlist = new Vector<char*>(size);
  Vector<char*> *newlist = new Vector<char*>(size);

  int i = 0;
  Vec_loop (pathmap_t*, path, index, pthmap)
  {
    oldlist->store (i, dbe_strdup (pthmap->old_prefix));
    newlist->store (i, dbe_strdup (pthmap->new_prefix));
    i++;
  }
  data->store (0, oldlist);
  data->store (1, newlist);
  return data;
} // dbeGetPathmaps

char *
dbeSetPathmaps (Vector<char*> *from, Vector<char*> *to)
{
  if (from == NULL || to == NULL || from->size () != to->size ())
    return dbe_strdup ("dbeSetPathmaps: size of 'from' does not match for size of 'to'\n");
  Vector<pathmap_t*> *newPath = new Vector<pathmap_t*>(from->size ());
  for (int i = 0, sz = from->size (); i < sz; i++)
    {
      char *err = Settings::add_pathmap (newPath, from->get (i), to->get (i));
      if (err)
        {
          newPath->destroy ();
          delete newPath;
          return err;
        }
    }
  dbeSession->set_pathmaps (newPath);
  return NULL;
}

//
// Add pathmap
char *
dbeAddPathmap (int /* dbevindex */, char *from, char *to)
{
  Vector<pathmap_t*> *pmp = dbeSession->get_pathmaps ();
  char *err = Settings::add_pathmap (pmp, from, to);
  return err;
}

//
// Get error/warning string of data
char *
dbeGetMsg (int dbevindex, int type)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  char *msgstr = NULL;
  if (type == ERROR_MSG)
    msgstr = dbev->get_error_msg ();
  else if (type == WARNING_MSG)
    msgstr = dbev->get_warning_msg ();
  else if (type == PSTAT_MSG)
    msgstr = dbev->get_processor_msg (PSTAT_MSG);
  else if (type == PWARN_MSG)
    msgstr = dbev->get_processor_msg (PWARN_MSG);
  return msgstr ? dbe_strdup (msgstr) : NULL;
}

// Create a DbeView, given new index, and index of view to clone
int
dbeInitView (int id, int cloneid)
{
  return dbeSession->createView (id, cloneid);
}


// Delete a DbeView
void
dbeDeleteView (int dbevindex)
{
  dbeSession->dropView (dbevindex);
  return;
} // dbeDeleteView

MetricList *
dbeGetMetricListV2 (int dbevindex, MetricType mtype,
                    Vector<int> *type, Vector<int> *subtype, Vector<bool> *sort,
                    Vector<int> *vis, Vector<char*> *cmd,
                    Vector<char*> *expr_spec, Vector<char*> *legends)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  MetricList *mlist = new MetricList (mtype);
  for (int i = 0, msize = type->size (); i < msize; i++)
    {
      BaseMetric *bm = dbev->register_metric_expr ((BaseMetric::Type) type->fetch (i),
                                                   cmd->fetch (i),
                                                   expr_spec->fetch (i));
      Metric *m = new Metric (bm, (Metric::SubType) subtype->fetch (i));
      m->set_raw_visbits (vis->fetch (i));
      if (m->legend == NULL)
        m->legend = dbe_strdup (legends->fetch (i));
      mlist->append (m);
      if (sort->fetch (i))
        {
          mlist->set_sort_ref_index (i);
        }
    }
  return mlist;
}

static Vector<void*> *
dbeGetMetricList (MetricList *mlist)
{
  int clock_val = dbeSession->get_clock (-1);
  Vector<Metric*> *items = mlist->get_items ();
  int size = items->size ();

  Vector<int> *type = new Vector<int>(size);
  Vector<int> *subtype = new Vector<int>(size);
  Vector<int> *clock = new Vector<int>(size);
  Vector<int> *flavors = new Vector<int>(size);
  Vector<int> *vis = new Vector<int>(size);
  Vector<bool> *sorted = new Vector<bool>(size);
  Vector<int> *value_styles = new Vector<int>(size);
  Vector<char*> *aux = new Vector<char*>(size);
  Vector<char*> *name = new Vector<char*>(size);
  Vector<char*> *abbr = new Vector<char*>(size);
  Vector<char*> *comd = new Vector<char*>(size);
  Vector<char*> *unit = new Vector<char*>(size);
  Vector<char*> *user_name = new Vector<char*>(size);
  Vector<char*> *expr_spec = new Vector<char*>(size);
  Vector<char*> *legend = new Vector<char*>(size);
  Vector<int> *valtype = new Vector<int>(size);
  Vector<char*> *data_type_name = new Vector<char*>(size);
  Vector<char*> *data_type_uname = new Vector<char*>(size);
  Vector<char*> *short_desc = new Vector<char*>(size);

  int sort_index = mlist->get_sort_ref_index ();
  // Fill metric elements
  for (int i = 0; i < size; i++)
    {
      Metric *m = items->fetch (i);
      type->append (m->get_type ());
      subtype->append (m->get_subtype ());
      flavors->append (m->get_flavors ());
      abbr->append (dbe_strdup (m->get_abbr ()));
      char *s = m->get_abbr_unit ();
      if ((m->get_visbits () & VAL_RATIO) != 0)
        s = NULL;
      unit->append (dbe_strdup (s ? s : NTXT ("")));
      value_styles->append (m->get_value_styles ());
      vis->append (m->get_visbits ());
      sorted->append (i == sort_index);
      clock->append (m->get_type () == Metric::HWCNTR ? clock_val
                     : m->get_clock_unit ());
      aux->append (dbe_strdup (m->get_aux ()));
      name->append (dbe_strdup (m->get_name ()));
      comd->append (dbe_strdup (m->get_cmd ()));
      user_name->append (dbe_strdup (m->get_username ()));
      expr_spec->append (dbe_strdup (m->get_expr_spec ()));
      legend->append (dbe_strdup (m->legend));
      valtype->append (m->get_vtype2 ());

      char* _data_type_name = NULL;
      char* _data_type_uname = NULL;
      int data_type = m->get_packet_type ();
      if (data_type >= 0 && data_type < DATA_LAST)
        {
          _data_type_name = dbe_strdup (get_prof_data_type_name (data_type));
          _data_type_uname = dbe_strdup (get_prof_data_type_uname (data_type));
        }
      data_type_name->append (_data_type_name);
      data_type_uname->append (_data_type_uname);

      char* _short_desc = NULL;
      if (m->get_type () == Metric::HWCNTR)
        {
          Hwcentry * hwctr = m->get_hw_ctr ();
          if (hwctr)
            _short_desc = dbe_strdup (hwctr->short_desc);
        }
      short_desc->append (_short_desc);
    }

  // Set Java array
  Vector<void*> *data = new Vector<void*>(16);
  data->append (type);
  data->append (subtype);
  data->append (clock);
  data->append (flavors);
  data->append (value_styles);
  data->append (user_name);
  data->append (expr_spec);
  data->append (aux);
  data->append (name);
  data->append (abbr);
  data->append (comd);
  data->append (unit);
  data->append (vis);
  data->append (sorted);
  data->append (legend);
  data->append (valtype);
  data->append (data_type_name);
  data->append (data_type_uname);
  data->append (short_desc);
  return data;
}

Vector<void*> *
dbeGetRefMetricsV2 ()
{
  MetricList *mlist = new MetricList (MET_NORMAL);
  Vector<BaseMetric*> *base_metrics = dbeSession->get_base_reg_metrics ();
  for (long i = 0, sz = base_metrics->size (); i < sz; i++)
    {
      BaseMetric *bm = base_metrics->fetch (i);
      Metric *m;
      if (bm->get_flavors () & Metric::EXCLUSIVE)
        {
          m = new Metric (bm, Metric::EXCLUSIVE);
          m->enable_all_visbits ();
          mlist->append (m);
        }
      else if (bm->get_flavors () & BaseMetric::STATIC)
        {
          m = new Metric (bm, BaseMetric::STATIC);
          m->enable_all_visbits ();
          mlist->append (m);
        }
    }
  Vector<void*> *data = dbeGetMetricList (mlist);
  delete mlist;
  return data;
}

Vector<void*> *
dbeGetCurMetricsV2 (int dbevindex, MetricType mtype)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  MetricList *mlist = dbev->get_metric_list (mtype);
  Vector<void*> *data = dbeGetMetricList (mlist);
  return data;
}

// YXXX we should refactor Metrics/BaseMetrics so that it no longer uses VAL_VALUE to enable time.
static int
convert_visbits_to_gui_checkbox_bits (BaseMetric *bm, const int visbits)
{
  // The purpose of this function is to handle the following case:
  //    When bm->get_value_styles() supports VAL_TIMEVAL but not VAL_VALUE
  //        Metric and BaseMetric use (visbits&VAL_VALUE) to enable time.
  //    However, the Overview expects the VAL_TIMEVAL bit to enable time.
  // Inputs: visbits as returned by BaseMetric->get_default_visbits();
  // Returns: valuebits, as used for checks in GUI checkboxes
  int valuebits = visbits;
  const int value_styles = bm->get_value_styles ();
  if ((value_styles & VAL_TIMEVAL) && // supports time
      !(value_styles & VAL_VALUE))
    { // but not value
      unsigned mask = ~(VAL_VALUE | VAL_TIMEVAL);
      valuebits = (unsigned) valuebits & mask; // clear bits
      if (visbits & VAL_VALUE)
        valuebits |= VAL_TIMEVAL; // set VAL_TIMEVAL
      if (visbits & VAL_TIMEVAL)
        valuebits |= VAL_TIMEVAL; // weird, this should never happen.
    }
  return valuebits;
}

static Vector<void*> *
dbeGetMetricTreeNode (BaseMetricTreeNode* curr, MetricList *mlist,
                      bool include_unregistered, bool has_clock_profiling_data)
{
  Vector<void*> *data = new Vector<void*>(2);

  // ----- fields
  Vector<void*> *fields = new Vector<void*>();
  Vector<char*> *name = new Vector<char*>(1);
  Vector<char*> *username = new Vector<char*>(1);
  Vector<char*> *description = new Vector<char*>(1);
  Vector<int> * flavors = new Vector<int>(1);
  Vector<int> * vtype = new Vector<int>(1);
  Vector<int> * vstyles_capable = new Vector<int>(1);

  // Specifies which default styles should be enabled when a metric is enabled.
  // Also, specifies if metric should start enabled
  Vector<int> *vstyles_e_defaults = new Vector<int>(1);
  Vector<int> *vstyles_i_defaults = new Vector<int>(1);
  Vector<bool> *registered = new Vector<bool>(1);
  Vector<bool> *aggregation = new Vector<bool>(1);
  Vector<bool> *has_value = new Vector<bool>(1);
  Vector<char*> *unit = new Vector<char*>(1);
  Vector<char*> *unit_uname = new Vector<char*>(1);

  char *_name = NULL;
  char *_username = NULL;
  char *_description = dbe_strdup (curr->get_description ());

  // BaseMetric fields
  int _flavors = 0; // SubType bitmask: (e.g. EXCLUSIVE)
  int _vtype = 0; // ValueTag: e.g. VT_INT, VT_FLOAT, ...
  int _vstyles_capable = 0; // ValueType bitmask, e.g. VAL_TIMEVAL
  int _vstyles_e_default_values = 0; // default visibility settings, exclusive/static
  int _vstyles_i_derault_values = 0; // default visibility settings, inclusive
  bool _registered = curr->is_registered ()
          || curr->get_num_registered_descendents () > 0;
  bool _aggregation = curr->is_composite_metric ()
          && curr->get_num_registered_descendents () > 0;
  bool _has_value = false; //not used yet; for nodes that don't have metrics
  char *_unit = NULL;
  char *_unit_uname = NULL;

  BaseMetric *bm = curr->get_BaseMetric ();
  if (bm)
    {
      _name = dbe_strdup (bm->get_cmd ());
      _username = dbe_strdup (bm->get_username ());
      if (!include_unregistered && !curr->is_registered ())
        abort ();
      _flavors = bm->get_flavors ();
      _vtype = bm->get_vtype ();
      _vstyles_capable = bm->get_value_styles ();
      int e_visbits = bm->get_default_visbits (BaseMetric::EXCLUSIVE);
      int i_visbits = bm->get_default_visbits (BaseMetric::INCLUSIVE);
      _vstyles_e_default_values = convert_visbits_to_gui_checkbox_bits (bm, e_visbits);
      _vstyles_i_derault_values = convert_visbits_to_gui_checkbox_bits (bm, i_visbits);
      // not all metrics shown in er_print cmd line should be selected in the GUI at startup:
      if (has_clock_profiling_data && bm->get_hw_ctr ())
        {
          bool hide = true; // by default, hide HWCs
          if (dbe_strcmp (bm->get_hw_ctr ()->name, NTXT ("c_stalls")) == 0 ||
              dbe_strcmp (bm->get_hw_ctr ()->name, NTXT ("K_c_stalls")) == 0)
            {
              bool is_time = (bm->get_value_styles () & VAL_TIMEVAL) != 0;
              if (is_time)
                // By default, show time variant of c_stalls
                hide = false;
            }
          if (hide)
            {
              _vstyles_e_default_values |= VAL_HIDE_ALL;
              _vstyles_i_derault_values |= VAL_HIDE_ALL;
            }
        }
    }
  else
    {
      // not a base metric
      _name = dbe_strdup (curr->get_name ());
      _username = dbe_strdup (curr->get_user_name ());
     if (curr->get_unit ())
        { // represents a value
          _has_value = true;
          _unit = dbe_strdup (curr->get_unit ());
          _unit_uname = dbe_strdup (curr->get_unit_uname ());
        }
    }
  name->append (_name); // unique id string (dmetrics cmd)
  username->append (_username); // user-visible name
  description->append (_description);
  flavors->append (_flavors); // SubType bitmask: (e.g. EXCLUSIVE)
  vtype->append (_vtype); // ValueTag: e.g. VT_INT, VT_FLOAT, ...
  vstyles_capable->append (_vstyles_capable); // ValueType bitmask, e.g. VAL_TIMEVAL
  vstyles_e_defaults->append (_vstyles_e_default_values);
  vstyles_i_defaults->append (_vstyles_i_derault_values);
  registered->append (_registered); // is a "live" metric
  aggregation->append (_aggregation); // value derived from children nodes
  has_value->append (_has_value); // value generated from other source
  unit->append (_unit); // See BaseMetric.h, e.g. UNIT_SECONDS
  unit_uname->append (_unit_uname); //See BaseMetric.h,

  fields->append (name);
  fields->append (username);
  fields->append (description);
  fields->append (flavors);
  fields->append (vtype);
  fields->append (vstyles_capable);
  fields->append (vstyles_e_defaults);
  fields->append (vstyles_i_defaults);
  fields->append (registered);
  fields->append (aggregation);
  fields->append (has_value);
  fields->append (unit);
  fields->append (unit_uname);
  data->append (fields);

  // ----- children
  Vector<BaseMetricTreeNode*> *children = curr->get_children ();
  int num_children = children->size ();
  Vector<void*> *children_list = new Vector<void*>(num_children);
  BaseMetricTreeNode *child_node;
  int index;

  Vec_loop (BaseMetricTreeNode*, children, index, child_node)
  {
    if (include_unregistered /* fetch everything */
        || child_node->is_registered ()
        || child_node->get_num_registered_descendents () > 0)
      {
        //Special case for metrics that aren't registered
        // but have registered children
        // Linux example: Total Time is unregistered, CPU Time is registered
        if (!include_unregistered && /* not fetching everything */
            !child_node->is_registered () &&
            (child_node->get_BaseMetric () != NULL ||
             child_node->is_composite_metric ()))
          {
            Vector<BaseMetricTreeNode*> *registered_descendents =
                    new Vector<BaseMetricTreeNode*>();
            child_node->get_nearest_registered_descendents (registered_descendents);
            int idx2;
            BaseMetricTreeNode*desc_node;
            Vec_loop (BaseMetricTreeNode*, registered_descendents, idx2, desc_node)
            {
              Vector<void*> *desc_data;
              desc_data = dbeGetMetricTreeNode (desc_node, mlist,
                                include_unregistered, has_clock_profiling_data);
              children_list->append (desc_data);
            }
            delete registered_descendents;
            continue;
          }
        Vector<void*> *child_data;
        child_data = dbeGetMetricTreeNode (child_node, mlist,
                                include_unregistered, has_clock_profiling_data);
        children_list->append (child_data);
      }
  }
  data->append (children_list);
  return data;
}

Vector<void*> *
dbeGetRefMetricTree (int dbevindex, bool include_unregistered)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  MetricList *mlist = dbev->get_metric_list (MET_NORMAL);
  bool has_clock_profiling_data = false;
  for (long i = 0, sz = mlist->get_items ()->size (); i < sz; i++)
    {
      Metric *m = mlist->get_items ()->fetch (i);
      if (m->get_packet_type () == DATA_CLOCK)
        {
          has_clock_profiling_data = true;
          break;
        }
    }
  BaseMetricTreeNode *curr = dbeSession->get_reg_metrics_tree ();
  return dbeGetMetricTreeNode (curr, mlist, include_unregistered, has_clock_profiling_data);
}

static Vector<void*> *
dbeGetTableDataV2Data (DbeView *dbev, Hist_data *data);

static Vector<void*> *dbeGetTableDataOneColumn (Hist_data *data, int met_ind);
static Vector<void*> *
dbeGetTableDataOneColumn (DbeView *dbev, Vector<Hist_data::HistItem*> *data,
                          ValueTag vtype, int metricColumnNumber);

static hrtime_t
dbeCalcGroupDuration (int grInd)
{
  int thisGroupSize = 1;
  hrtime_t max_time = 0;
  Experiment *exp;
  if (dbeSession->expGroups->size () > 0)
    {
      ExpGroup *grp = dbeSession->expGroups->fetch (grInd);
      thisGroupSize = grp->exps->size ();
      for (int ii = 0; ii < thisGroupSize; ii++)
        {
          exp = grp->exps->fetch (ii);
          Vector<DataDescriptor*> *ddscr = exp->getDataDescriptors ();
          delete ddscr;// getDataDescriptors() forces reading of experiment data
          if (exp != NULL)
            {
              hrtime_t tot_time = exp->getLastEvent () - exp->getStartTime ()
                      + exp->getRelativeStartTime ();
              if (max_time < tot_time)
                max_time = tot_time;
            }
        }
    }
  else
    {
      exp = dbeSession->get_exp (0);
      if (exp != NULL)
        max_time = exp->getLastEvent () - exp->getStartTime ();
    }
  return max_time; //nanoseconds
}

static hrtime_t
dbeCalcGroupGCDuration (int grInd)
{
  int thisGroupSize = 1;
  hrtime_t tot_time = 0;
  Experiment *exp;
  if (dbeSession->expGroups->size () > 0)
    {
      ExpGroup *grp = dbeSession->expGroups->fetch (grInd);
      thisGroupSize = grp->exps->size ();
      for (int ii = 0; ii < thisGroupSize; ii++)
        {
          exp = grp->exps->fetch (ii);
          Vector<DataDescriptor*> *ddscr = exp->getDataDescriptors ();
          delete ddscr; // getDataDescriptors() forces reading of experiment data
          if (exp != NULL)
            tot_time += exp->getGCDuration ();
        }
    }
  else
    {
      exp = dbeSession->get_exp (0);
      if (exp != NULL)
        tot_time = exp->getGCDuration ();
    }
  return tot_time; //nanoseconds
}

Vector<void*> *
dbeGetRefMetricTreeValues (int dbevindex, Vector<char *> *metric_cmds,
                           Vector<char *> *non_metric_cmds)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  // valueTable will have N "columns" of values, where N is the number of
  //   requested metrics and non-metrics.
  // Each column will be a vector with M "rows", where M is the number of
  //   compare groups.
  // highlightTable mirrors the structure of valueTable.  Each cell indicates
  //   if the corresponding valueTable cell is "hot" (interesting)
  int numMetrics = metric_cmds->size ();
  int numNonMetrics = non_metric_cmds->size ();
  int totalColumns = numMetrics + numNonMetrics; // Columns
  Vector<void*> *valueTable = new Vector<void*>(totalColumns);
  Vector<void*> *highlightTable = new Vector<void*>(totalColumns);

  // the return value consists of the two tables discussed above.
  Vector<void*> *rc = new Vector<void*>(2);
  rc->append (valueTable);
  rc->append (highlightTable);
  if (dbeSession->nexps () == 0)
    { // no experiments are loaded
      for (int jj = 0; jj < totalColumns; jj++)
        {
          Vector<void *> *columnData = new Vector<void *>();
          valueTable->append (columnData);
          highlightTable->append (columnData);
        }
      return rc;
    }

  int ngroups = dbeSession->expGroups->size (); // Rows (one per compare group)
  if (ngroups == 0 || !dbev->comparingExperiments ())
    ngroups = 1;

  Vector<double> *groupTotalTime = new Vector<double>(ngroups);
  Vector<double> *groupCpuTime = new Vector<double>(ngroups);
  // initialize highlight table
  for (int ii = 0; ii < totalColumns; ii++)
    { // metrics
      Vector<bool> *columnData = new Vector<bool>(ngroups);
      highlightTable->append (columnData);
      for (int grInd = 0; grInd < ngroups; grInd++)
        columnData->store (grInd, false); // non-highlight
    }

  if (numMetrics > 0)
    {
      MetricList *bmlist;
      // set bmlist to list of requested base metrics
      BaseMetricTreeNode *root = dbeSession->get_reg_metrics_tree ();
      int index;
      char *mcmd;
      Vector<BaseMetric*> *base_metrics = new Vector<BaseMetric*>();
      Vec_loop (char *, metric_cmds, index, mcmd)
      {
        BaseMetricTreeNode *bmt_node = root->find (mcmd);
        if (!bmt_node)
          abort (); //YXXX weird
        BaseMetric * baseNetric = bmt_node->get_BaseMetric ();
        if (!baseNetric)
          abort ();
        base_metrics->append (baseNetric);
      }

      // MET_INDX will create MetricList of Exclusive metrics
      bmlist = new MetricList (base_metrics, MET_SRCDIS);

      // Use the Function List to fetch <Total> values
      // A temporary table, v_totals, stores <total> by group
      Vector<Hist_data::HistItem *> *v_totals = new Vector<Hist_data::HistItem *>(ngroups);
      for (int grInd = 0; grInd < ngroups; grInd++)
        {
          MetricList *mlist;
          if (ngroups > 1)
            mlist = dbev->get_compare_mlist (bmlist, grInd);
          else
            mlist = bmlist;
          if (mlist->size () != numMetrics)
            abort ();

          Hist_data *data;
          data = dbev->get_hist_data (mlist, Histable::FUNCTION, 0,
                                      Hist_data::ALL);
          Hist_data::HistItem * totals = data->get_totals ();
          v_totals->append (totals);
        }

      // store the Hist_data totals in valueTable
      {
        Metric *mitem;
        int index;
        Vec_loop (Metric*, bmlist->get_items (), index, mitem)
        {
          Vector<void*> * columnData = dbeGetTableDataOneColumn (dbev,
                                          v_totals, mitem->get_vtype (), index);
          valueTable->append (columnData);
        }
      }

      // 7207285: hack for hwc profiling cycles conversion:
      {
        Metric *mitem;
        int index;
        Vec_loop (Metric*, bmlist->get_items (), index, mitem)
        {
          if (mitem->is_time_val ()
              && mitem->get_vtype () == VT_ULLONG)
            {
              Vector<long long> *cycleValues = (Vector<long long> *)valueTable->fetch (index);
              Vector<double> *timeValues = new Vector<double>(ngroups);
              assert (cycleValues->size () == ngroups);
              for (int grInd = 0; grInd < ngroups; grInd++)
                {
                  long long cycles = cycleValues->fetch (grInd);
                  int expId;
                  if (dbeSession->expGroups->size () > 0)
                    {
                      ExpGroup *gr = dbeSession->expGroups->fetch (grInd);
                      Experiment *exp = gr->exps->fetch (0);
                      expId = exp->getExpIdx ();
                    }
                  else
                    expId = -1;
                  int clock = dbeSession->get_clock (expId);
                  double time;
                  if (clock)
                    time = cycles / (1.e+6 * clock);
                  else
                    time = cycles; //weird
                  timeValues->store (grInd, time);
                }
              delete cycleValues;
              valueTable->store (index, timeValues);
            }
        }
      }

      // Scan metrics for best measure of CPU time
      int bestCpuTimeIndx = -1;
      {
        Metric *mitem;
        int index;
        Vec_loop (Metric*, bmlist->get_items (), index, mitem)
        {
          BaseMetric::Type type = mitem->get_type ();
          if (type == BaseMetric::CP_KERNEL_CPU)
            {
              bestCpuTimeIndx = index;
              break; // CP_KERNEL_CPU trumps other measures
            }
          if (type == BaseMetric::CP_TOTAL_CPU)
            {
              // clock profiling CPU time
              bestCpuTimeIndx = index;
              // keep looking in case CP_KERNEL_CPU also exists
              continue;
            }

          bool isTime = ((mitem->get_value_styles () & VAL_TIMEVAL) != 0);
          bool isHwcCycles = (type == BaseMetric::HWCNTR
                              && (dbe_strcmp (mitem->get_aux (), "cycles") == 0)
                              && isTime);
          if (isHwcCycles)
            if (bestCpuTimeIndx < 0)
              bestCpuTimeIndx = index;
        }
        if (bestCpuTimeIndx >= 0)
          {
            Vector<double> *timeValues = (Vector<double> *)valueTable->fetch (bestCpuTimeIndx);
            if (timeValues->type () == VEC_DOUBLE)
              for (int grInd = 0; grInd < ngroups; grInd++)
                {
                  double time = timeValues->fetch (grInd);
                  groupCpuTime->append (time);
                }
          }
      }

      // Scan metrics for Total Thread time
      {
        Metric *mitem;
        int index;
        Vec_loop (Metric*, bmlist->get_items (), index, mitem)
        {
          BaseMetric::Type type = mitem->get_type ();
          if (type == BaseMetric::CP_TOTAL)
            {
              Vector<double> *timeValues = (Vector<double> *)valueTable->fetch (index);
              if (timeValues->type () != VEC_DOUBLE)
                continue; // weird
              for (int grInd = 0; grInd < ngroups; grInd++)
                {
                  double time = timeValues->fetch (grInd);
                  groupTotalTime->append (time);
                }
              break;
            }
        }
      }

      // highlight metrics based on cpu time
#define CPUSEC_PERCENT_THRESHOLD            10.0
#define HWC_OVERFLOWS_PER_CPUSEC_THRESHOLD  15
      {
        Metric *mitem;
        int index;
        Vec_loop (Metric*, bmlist->get_items (), index, mitem)
        {
          BaseMetric::Type type = mitem->get_type ();
          Vector<bool> * columnHilites = (Vector<bool> *)highlightTable->fetch (index);

          // always highlight the following
          if (index == bestCpuTimeIndx)
            {
              for (int grInd = 0; grInd < ngroups; grInd++)
                columnHilites->store (grInd, true);
              continue;
            }

          // skip certain types
          bool typeIsCycles = (type == BaseMetric::HWCNTR
                       && dbe_strcmp (mitem->get_aux (), NTXT ("cycles")) == 0);
          bool typeIsInsts = (type == BaseMetric::HWCNTR
                        && dbe_strcmp (mitem->get_aux (), NTXT ("insts")) == 0);
          if (type == BaseMetric::CP_TOTAL
              || type == BaseMetric::CP_TOTAL_CPU
              || type == BaseMetric::CP_LMS_USER
              || type == BaseMetric::CP_LMS_SYSTEM
              || type == BaseMetric::CP_LMS_TRAP
              || type == BaseMetric::CP_LMS_USER_LOCK
              || type == BaseMetric::CP_LMS_SLEEP
              || type == BaseMetric::CP_KERNEL_CPU
              || type == BaseMetric::OMP_WORK
              || typeIsCycles
              || typeIsInsts
              // || type == BaseMetric::CP_TOTAL_WAIT
              )
            continue; // types we never highlight

          // for time values, compare against CPUSEC_PERCENT_THRESHOLD
          bool isTime = ((mitem->get_value_styles () & VAL_TIMEVAL) != 0);
          if (isTime)
            {
              if (groupCpuTime->size () == 0)
                continue; // no time to use as reference
              Vector<double> *timeValues = (Vector<double> *)valueTable->fetch (index);
              if (timeValues->type () != VEC_DOUBLE)
                continue; // weird
              for (int grInd = 0; grInd < ngroups; grInd++)
                {
                  double thistime = timeValues->fetch (grInd);
                  double usertime = groupCpuTime->fetch (grInd);
                  if (thistime / (CPUSEC_PERCENT_THRESHOLD / 100) > usertime)
                    columnHilites->store (grInd, true);
                }
              continue;
            }

          // for HWC event counts, look at rate of events
          if (type == BaseMetric::HWCNTR)
            {
              Hwcentry *hwctr = mitem->get_hw_ctr ();
              if (!hwctr)
                continue; // weird
              if (!hwctr->metric)
                continue; // raw counter
              if (groupCpuTime->size () == 0)
                continue; // no time to use as reference
              if (mitem->get_base_metric ()->get_dependent_bm ())
                continue; // has a derived time metric, only flag time version
              Vector<long long> *llValues = (Vector<long long> *)valueTable->fetch (index);
              if (llValues->type () != VEC_LLONG)
                continue; // weird
              int overflowVal = hwctr->val; //overflow count
              if (!overflowVal)
                continue; // weird
              if (overflowVal > (4000000))
                // cut off events that are very frequent like loads/stores
                // 4Ghz * (0.01 seconds/event) / (4000000 events/overflow) = 10 cycles
                continue;
              // for HWCs we could base it on the overflow rate
              for (int grInd = 0; grInd < ngroups; grInd++)
                {
                  double thisVal = llValues->fetch (grInd);
                  thisVal /= overflowVal;
                  double usertime = groupCpuTime->fetch (grInd);
                  if (thisVal > usertime * HWC_OVERFLOWS_PER_CPUSEC_THRESHOLD)
                    columnHilites->store (grInd, true);
                }
              continue;
            }

          // check for non-zero counts of the following
          if (type == BaseMetric::DEADLOCKS ||
              type == BaseMetric::RACCESS ||
              type == BaseMetric::HEAP_ALLOC_BYTES ||
              type == BaseMetric::HEAP_LEAK_BYTES)
            {
              Vector<long long> *llValues = (Vector<long long> *)valueTable->fetch (index);
              if (llValues->type () != VEC_LLONG)
                continue; // weird
              for (int grInd = 0; grInd < ngroups; grInd++)
                {
                  long long thisVal = llValues->fetch (grInd);
                  if (thisVal)
                    columnHilites->store (grInd, true);
                }
              continue;
            }
          // continue adding cases as needed
        }
      }
    }

  if (numNonMetrics > 0)
    {
      int index;
      char *mcmd;
      Vec_loop (char *, non_metric_cmds, index, mcmd)
      {
        if (dbe_strcmp (mcmd, NTXT ("YXXX_TOTAL_TIME_PLUS_THREADS")) == 0
            && groupCpuTime->size () == ngroups)
          {
            Vector<char *> *columnData = new Vector<char *>(ngroups);
            for (int grInd = 0; grInd < ngroups; grInd++)
              {
                double totaltime = groupTotalTime->fetch (grInd);
                columnData->append (dbe_sprintf (NTXT ("%0.3f %s"), totaltime, GTXT ("Seconds")));
              }
            valueTable->append (columnData);
          }
        else if (dbe_strcmp (mcmd, L1_DURATION) == 0)
          {
            Vector<double> *columnData = new Vector<double>(ngroups);
            for (int grInd = 0; grInd < ngroups; grInd++)
              {
                hrtime_t duration = dbeCalcGroupDuration (grInd);
                double seconds = duration * 1.e-9;
                columnData->append (seconds);
              }
            valueTable->append (columnData);
          }
        else if (dbe_strcmp (mcmd, L1_GCDURATION) == 0)
          {
            Vector<double> *columnData = new Vector<double>(ngroups);
            for (int grInd = 0; grInd < ngroups; grInd++)
              {
                hrtime_t duration = dbeCalcGroupGCDuration (grInd);
                double seconds = duration * 1.e-9;
                columnData->append (seconds);
              }
            valueTable->append (columnData);
          }
        else
          {
            Vector<char *> *columnData = new Vector<char *>(ngroups);
            char * valueString = NTXT ("<unknown>");
            for (int grInd = 0; grInd < ngroups; grInd++)
              columnData->append (dbe_strdup (valueString));
            valueTable->append (columnData);
          }
      }
    }
  return rc;
}

Vector<char*> *
dbeGetOverviewText (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  Vector<char*> *info = new Vector<char*>;
  char *field;
  int ngroups = dbeSession->expGroups->size (); // Rows (one per compare group)
  if (ngroups == 0 || !dbev->comparingExperiments ())
    ngroups = 1;
  for (int grInd = 0; grInd < ngroups; grInd++)
    {
      int thisGroupSize = 1;
      Experiment *exp;
      if (dbeSession->expGroups->size () > 0)
        {
          ExpGroup *gr = dbeSession->expGroups->fetch (grInd);
          exp = gr->exps->fetch (0);
          thisGroupSize = gr->exps->size ();
        }
      else
        {
          if (dbeSession->nexps () == 0)
            return info;
          exp = dbeSession->get_exp (0);
        }
      char * expHeader;
      if (ngroups == 1)
        expHeader = dbe_strdup (GTXT ("Experiment      :"));
      else if (grInd == 0)
        expHeader = dbe_strdup (GTXT ("Base Group      : "));
      else if (ngroups == 2)
        expHeader = dbe_strdup (GTXT ("Compare Group   : "));
      else
        expHeader = dbe_sprintf (GTXT ("Compare Group %d : "), grInd);
      if (thisGroupSize == 1)
        info->append (dbe_sprintf ("%s%s", expHeader, exp->get_expt_name ()));
      else
        info->append (dbe_sprintf ("%s%s (plus %d more)",
                          expHeader, exp->get_expt_name (), thisGroupSize - 1));
      free (expHeader);
      field = exp->uarglist;
      if (field && field[0])
        info->append (dbe_sprintf (GTXT ("  Target        : '%s'"), field));
      field = exp->hostname;
      if (field && field[0])
        info->append (dbe_sprintf (GTXT ("  Host          : %s (%s, %s)"),
                                   field,
                                   exp->architecture ? exp->architecture
                                   : GTXT ("<CPU architecture not recorded>"),
                                   exp->os_version ? exp->os_version
                                   : GTXT ("<OS version not recorded>")));
      time_t start_sec = (time_t) exp->start_sec;
      char *p = ctime (&start_sec);
      hrtime_t tot_time = dbeCalcGroupDuration (grInd);
      double seconds = tot_time * 1.e-9;
      info->append (dbe_sprintf (
                GTXT ("  Start Time    : %s  Duration      : %0.3f Seconds"),
                p, seconds));
      // Number of descendants/processes would be nice
      info->append (dbe_strdup (NTXT ("")));
    }
  return info;
}

//--------------------------------------------------------------------------
// Set Sort by index
//
void
dbeSetSort (int dbevindex, int sort_index, MetricType mtype, bool reverse)
{
  DbeView *dbev;

  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->setSort (sort_index, mtype, reverse);
  return;
}

//
// Get annotation setting
//
Vector<int> *
dbeGetAnoValue (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<int> *set = new Vector<int>(9);
  set->store (0, dbev->get_src_compcom ());
  set->store (1, dbev->get_dis_compcom ());
  set->store (2, dbev->get_thresh_src ());
  set->store (3, dbev->get_thresh_src ());
  set->store (4, dbev->get_src_visible ());
  set->store (5, (int) dbev->get_srcmetric_visible ());
  set->store (6, (int) dbev->get_hex_visible ());
  set->store (7, (int) dbev->get_cmpline_visible ());
  set->store (8, (int) dbev->get_func_scope ());
  return set;
}

//
// Set annotation setting
//
void
dbeSetAnoValue (int dbevindex, Vector<int> *set)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (set->size () != 10)
    return;
  dbev->set_src_compcom (set->fetch (0));
  dbev->set_dis_compcom (set->fetch (1));
  dbev->set_thresh_src (set->fetch (2));
  dbev->set_thresh_dis (set->fetch (3));
  dbev->set_src_visible (set->fetch (4));
  dbev->set_srcmetric_visible ((bool)set->fetch (5));
  dbev->set_hex_visible ((bool)set->fetch (6));
  dbev->set_cmpline_visible ((bool)set->fetch (7));
  dbev->set_func_scope (set->fetch (8));
  dbev->set_funcline_visible ((bool)set->fetch (9));
  return;
}

//
// Get name formats
//
int
dbeGetNameFormat (int dbevindex)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable::NameFormat fmt = dbev->get_name_format ();
  return Histable::fname_fmt (fmt);
}

bool
dbeGetSoName (int dbevindex)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable::NameFormat fmt = dbev->get_name_format ();
  return Histable::soname_fmt (fmt);
}

//
// Set name formats
//
void
dbeSetNameFormat (int dbevindex, int nformat, bool soname)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_name_format (nformat, soname);
}

//
// Get View mode
//
int
dbeGetViewMode (int dbevindex)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  return (int) dbev->get_view_mode ();
}

// Set View mode
void
dbeSetViewMode (int dbevindex, int nmode)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_view_mode ((VMode) nmode);
  return;
}

// Get timeline setting
//
Vector<void*> *
dbeGetTLValue (int dbevindex)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<char *> *strings = new Vector<char *>();
  char *tldata_cmd = dbev->get_tldata ();
  strings->store (0, tldata_cmd);

  Vector<int> *ints = new Vector<int>(3);
  int val;
  val = dbev->get_tlmode ();
  ints->store (0, val);
  val = dbev->get_stack_align ();
  ints->store (1, val);
  val = dbev->get_stack_depth ();
  ints->store (2, val);

  Vector<void*> *objs = new Vector<void*>(2);
  objs->store (0, strings);
  objs->store (1, ints);
  return objs;
}

//
// Set timeline setting
//
void
dbeSetTLValue (int dbevindex, const char *tldata_cmd,
               int entitiy_prop_id, int stackalign, int stackdepth)
{
  DbeView *dbev;
  dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_tldata (tldata_cmd);
  dbev->set_tlmode (entitiy_prop_id);
  dbev->set_stack_align (stackalign);
  dbev->set_stack_depth (stackdepth);
  return;
}

//
// Get founder experiments and their descendants
//
Vector<void*> *
dbeGetExpFounderDescendants ()
{
  int size = dbeSession->nexps ();
  if (size == 0)
    return NULL;
  Vector<void*> *table = new Vector<void*>(2);
  Vector<int> *founderExpIds = new Vector<int>();
  Vector<Vector<int> *> *subExpIds = new Vector<Vector<int>*>();
  for (int index = 0; index < size; index++)
    {
      Experiment *exp = dbeSession->get_exp (index);
      if (exp->founder_exp == NULL)
        {
          founderExpIds->append (exp->getExpIdx ());
          Vector<int> *subExps = new Vector<int>();
          for (int i = 0; i < exp->children_exps->size (); i++)
            {
              Experiment * subExp = exp->children_exps->fetch (i);
              subExps->append (subExp->getExpIdx ());
            }
          subExpIds->append (subExps);
        }
    }
  table->store (0, founderExpIds);
  table->store (1, subExpIds);
  return table;
}

//
// Get experiment selection
//
Vector<void*> *
dbeGetExpSelection (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  int size = dbeSession->nexps ();
  if (size == 0)
    return NULL;
  Vector<void*> *table = new Vector<void*>(3);
  Vector<char*> *names = new Vector<char*>(size);
  Vector<bool> *enable = new Vector<bool>(size);
  Vector<int> *userExpIds = new Vector<int>(size);

  // Get experiment names
  for (int index = 0; index < size; index++)
    {
      Experiment *exp = dbeSession->get_exp (index);
      char *buf = dbeGetName (dbevindex, index);
      names->store (index, buf);
      bool val;
      val = dbev->get_exp_enable (index);
      enable->store (index, val);
      userExpIds->store (index, exp->getUserExpId ());
    }
  table->store (0, names);
  table->store (1, enable);
  table->store (2, userExpIds);
  return table;
}

int
dbeValidateFilterExpression (char *str_expr)
{
  if (str_expr == NULL)
    return 0;
  Expression *expr = dbeSession->ql_parse (str_expr);
  if (expr == NULL)
    return 0;
  delete expr;
  return 1;
}

Vector<void*> *
dbeGetFilterKeywords (int /* dbevindex */)
{
  Vector <char*> *kwCategory = new Vector<char *>();
  Vector <char*> *kwCategoryI18N = new Vector<char *>();
  Vector <char*> *kwDataType = new Vector<char *>();
  Vector <char*> *kwKeyword = new Vector<char *>();
  Vector <char*> *kwFormula = new Vector<char *>();
  Vector <char*> *kwDescription = new Vector<char *>();
  Vector <void*> *kwEnumDescs = new Vector<void *>();

  Vector<void*> *res = new Vector<void*>(7);
  res->append (kwCategory);
  res->append (kwCategoryI18N);
  res->append (kwDataType);
  res->append (kwKeyword);
  res->append (kwFormula);
  res->append (kwDescription);
  res->append (kwEnumDescs);

  char *vtypeNames[] = VTYPE_TYPE_NAMES;
  // section header for global definitions
  kwCategory->append (dbe_strdup (NTXT ("FK_SECTION")));
  kwCategoryI18N->append (dbe_strdup (GTXT ("Global Definitions")));
  kwDataType->append (NULL);
  kwKeyword->append (NULL);
  kwFormula->append (NULL);
  kwDescription->append (NULL);
  kwEnumDescs->append (NULL);
  dbeSession->get_filter_keywords (res);
  MemorySpace::get_filter_keywords (res);

  // loop thru all founder experiments
  int nexp = dbeSession->nexps ();
  for (int ii = 0; ii < nexp; ++ii)
    {
      Experiment* fexp = dbeSession->get_exp (ii);
      if (fexp->founder_exp != NULL)
        continue; // is a child; should be covered when we get to founder

      // section header for each founder
      // section header for founder experiment
      kwCategory->append (dbe_strdup (NTXT ("FK_SECTION")));
      kwCategoryI18N->append (dbe_sprintf (NTXT ("%s [EXPGRID==%d]"),
                                           fexp->get_expt_name (),
                                           fexp->groupId));
      kwDataType->append (NULL);
      kwKeyword->append (NULL);
      kwFormula->append (NULL);
      kwDescription->append (NULL);
      kwEnumDescs->append (NULL);

      int nchildren = fexp->children_exps->size ();
      Experiment *exp;
      // category header: Experiments
      {
        char *propUName = dbeSession->getPropUName (PROP_EXPID);

        // store list of subexperiments in kwEnumDescs
        Vector <char*> *enumDescs = new Vector<char *>();
        int jj = 0;
        exp = fexp;
        while (1)
          {
            char * expBasename = get_basename (exp->get_expt_name ());
            char * targetName = exp->utargname ? exp->utargname
                    : (char *) GTXT ("(unknown)");
            enumDescs->append (dbe_sprintf (NTXT ("(%d) -> %s [%s, PID %d]"),
                                            exp->getUserExpId (), expBasename,
                                            targetName, exp->getPID ()));
            if (jj >= nchildren)
              break;
            exp = fexp->children_exps->fetch (jj);
            jj++;
          }
        kwCategory->append (dbe_strdup (NTXT ("FK_EXPLIST")));
        kwCategoryI18N->append (dbe_strdup (GTXT ("Experiments")));
        kwDataType->append (dbe_strdup (vtypeNames[TYPE_INT32]));
        kwKeyword->append (dbe_strdup (NTXT ("EXPID")));
        kwFormula->append (NULL);
        kwDescription->append (propUName);
        kwEnumDescs->append (enumDescs);
      }

      // select representative experiment
      if (nchildren == 0)
        exp = fexp; // founder
      else
        exp = fexp->children_exps->fetch (0); // first child
      int expIdx = exp->getExpIdx ();
      Vector<void*> *data = dbeGetDataDescriptorsV2 (expIdx);
      if (data == NULL)
        continue;
      Vector<int> *dataId = (Vector<int>*)data->fetch (0);
      Vector<char*> *dataName = (Vector<char*>*)data->fetch (1);
      Vector<char*> *dataUName = (Vector<char*>*)data->fetch (2);
      if (dataId == NULL || dataName == NULL)
        {
          destroy (data);
          continue;
        }
      // loop thru data descriptors
      int ndata = dataId->size ();
      for (int j = 0; j < ndata; ++j)
        {
          // category: data name (e.g. Clock Profiling)
          char * catName = dataName->fetch (j);
          char * dUname = dataUName ? dataUName->fetch (j) : catName;
          char * catUname = dUname ? dUname : catName;

          Vector<void*> *props = dbeGetDataPropertiesV2 (expIdx, dataId->fetch (j));
          if (props == NULL)
            continue;
          Vector<char*> *propUName = (Vector<char*>*)props->fetch (1);
          Vector<int> *propTypeId = (Vector<int> *)props->fetch (2);
          Vector<char*> *propType = (Vector<char*>*)props->fetch (3);
          Vector<char*> *propName = (Vector<char*>*)props->fetch (5);
          Vector<Vector<char*>*> *propStateNames =
                  (Vector<Vector<char*>*> *)props->fetch (6);
          Vector<Vector<char*>*> *propStateUNames =
                  (Vector<Vector<char*>*> *)props->fetch (7);
          if (propName == NULL || propUName == NULL || propType == NULL
              || propName->size () <= 0)
            {
              destroy (props);
              continue;
            }
          int nprop = propName->size ();
          for (int k = 0; k < nprop; ++k)
            {
              if (propTypeId->fetch (k) == TYPE_OBJ)
                continue;
              if (dbe_strcmp (propName->fetch (k), NTXT ("FRINFO")) == 0)
                continue;

              // store list of states in kwEnumDescs
              Vector<char*> *enumDescs = new Vector<char *>();
              Vector<char*>* stateNames = propStateNames->fetch (k);
              Vector<char*>* stateUNames = propStateUNames->fetch (k);
              int nStates = stateNames ? stateNames->size () : 0;
              for (int kk = 0; kk < nStates; ++kk)
                {
                  const char *stateName = stateNames->fetch (kk);
                  if (stateName == NULL || strlen (stateName) == 0)
                    continue;
                  const char *stateUName = stateUNames->fetch (kk);
                  if (stateUName == NULL || strlen (stateUName) == 0)
                    stateUName = stateName;
                  enumDescs->append (dbe_sprintf (NTXT ("(%d) -> %s"), kk, stateUName));
                }
              kwCategory->append (dbe_strdup (catName));
              kwCategoryI18N->append (dbe_strdup (catUname));
              kwDataType->append (dbe_strdup (propType->fetch (k)));
              kwKeyword->append (dbe_strdup (propName->fetch (k)));
              kwFormula->append (NULL);
              kwDescription->append (dbe_strdup (propUName->fetch (k)));
              kwEnumDescs->append (enumDescs);
            }
          destroy (props);
        }
      destroy (data);
    }
  return (res);
}

// GetFilters -- returns the list of filters for the indexed experiment
//      returns false if there's a problem; true otherwise
//
Vector<void*> *
dbeGetFilters (int dbevindex, int nexp)
{
  FilterNumeric *filt;
  int index;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<FilterNumeric *>*filters = dbev->get_all_filters (nexp);
  if (filters == NULL)
    return NULL;

  // return an array of filter data for that experiment
  Vector <int> *findex = new Vector<int>(); // index of the filters
  Vector <char*> *shortname = new Vector<char *>();
  // short name of filter
  Vector <char*> *i18n_name = new Vector<char *>();
  // External I18N'd name of filter
  Vector <char*> *pattern = new Vector<char *>();
  // current setting string
  Vector <char*> *status = new Vector<char *>();
  // current status of filter (%, range, etc.)

  Vec_loop (FilterNumeric *, filters, index, filt)
  {
    findex->append (index);
    shortname->append (dbe_strdup (filt->get_cmd ()));
    i18n_name->append (dbe_strdup (filt->get_name ()));
    pattern->append (dbe_strdup (filt->get_pattern ()));
    status->append (dbe_strdup (filt->get_status ()));
  }
  Vector<void*> *res = new Vector<void*>(5);
  res->store (0, findex);
  res->store (1, shortname);
  res->store (2, i18n_name);
  res->store (3, pattern);
  res->store (4, status);
  return (res);
}

// Set a filter string for a view
//      Returns NULL if OK, error message if not

char *
dbeSetFilterStr (int dbevindex, char *filter_str)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->clear_error_msg ();
  dbev->clear_warning_msg ();
  char *ret = dbev->set_filter (filter_str);
  return ret;
}

// Get the current filter setting for the view
char *
dbeGetFilterStr (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  char *ret = dbev->get_filter ();
  return ret;
}

// Update a filters for a single experiment
// Returns true if any filter->set_pattern() returns true,
//      implying rereading the data is needed (i.e., a filter changed)
//
bool
dbeUpdateFilters (int dbevindex, Vector<bool> *selected, Vector<char *> *pattern_str)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->clear_error_msg ();
  dbev->clear_warning_msg ();

  // Get index of first selected experiment
  int size = selected->size ();
  int nselexp = -1;
  for (int index = 0; index < size; index++)
    {
      if (selected->fetch (index) == true)
        {
          nselexp = index;
          break;
        }
    }
  if (nselexp == -1) // No experiment selected
    return false;

  bool ret = false;
  for (int j = 0; j < size; j++)
    {
      if (selected->fetch (j) == false)
        continue;
      bool error;
      if (dbev->set_pattern (j, pattern_str, &error))
        ret = true;
    }
  dbev->update_advanced_filter ();
  return ret;
}

char *
dbeComposeFilterClause (int dbevindex, int type, int subtype, Vector<int> *selections)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  // ask the cached data to generate the string
  Hist_data *data;
  switch (type)
    {
    case DSP_FUNCTION:
      data = dbev->func_data;
      break;
    case DSP_DLAYOUT:
      data = dbev->dlay_data;
      break;
    case DSP_DATAOBJ:
      data = dbev->dobj_data;
      break;
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      data = dbev->get_indxobj_data (subtype);
      break;
    case DSP_LINE:
      data = dbev->line_data;
      break;
    case DSP_PC:
      data = dbev->pc_data;
      break;
    case DSP_SOURCE:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
      data = dbev->dis_data;
      break;
    case DSP_IOACTIVITY:
      data = dbev->iofile_data;
      break;
    case DSP_IOVFD:
      data = dbev->iovfd_data;
      break;
    case DSP_IOCALLSTACK:
      data = dbev->iocs_data;
      break;
    case DSP_HEAPCALLSTACK:
      data = dbev->heapcs_data;
      break;
    default:
      return NULL;
    }
  if (data == NULL)
    return NULL;

  // Get array of object indices, and compose filter string
  Vector<uint64_t> *obj_ids = data->get_object_indices (selections);
  if (obj_ids == NULL || obj_ids->size () == 0)
    return NULL;

  uint64_t sel;
  int index;
  int found = 0;
  char buf[128];
  StringBuilder sb;
  sb.append ('(');
  switch (type)
    {
    case DSP_LINE:
    case DSP_PC:
    case DSP_SOURCE:
    case DSP_DISASM:
    case DSP_FUNCTION:
      sb.append (NTXT ("LEAF IN "));
      break;
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      sb.append (dbeSession->getIndexSpaceName (subtype));
      sb.append (NTXT (" IN "));
      break;
    }
  Vec_loop (uint64_t, obj_ids, index, sel)
  {
    if (found == 0)
      {
        found = 1;
        sb.append ('(');
      }
    else
      sb.append (NTXT (", "));
    snprintf (buf, sizeof (buf), NTXT ("%llu"), (long long) sel);
    sb.append (buf);
  }
  if (found == 1)
    sb.append (')');

  switch (type)
    {
    case DSP_DLAYOUT:
    case DSP_DATAOBJ:
      sb.append (NTXT (" SOME IN DOBJ"));
      break;
    }
  sb.append (')');
  return sb.toString ();
}

//
// Get load object states
//
Vector<void *> *
dbeGetLoadObjectList (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<LoadObject*> *lobjs = dbeSession->get_text_segments ();
  int size = lobjs->size ();

  // Initialize Java boolean array
  Vector<char *> *names = new Vector<char *>(size);
  Vector<int> *states = new Vector<int>(size);
  Vector<int> *indices = new Vector<int>(size);
  Vector<char *> *paths = new Vector<char *>(size);
  Vector<int> *isJava = new Vector<int>(size);

  // Get load object states
  int index;
  LoadObject *lo;
  char *lo_name;

  // lobjectsNoJava is a trimmed list of indices provided to front-end skipping the Java
  // classes. lobjectsNoJava preserves the mapping of the index into the complete lobjs
  // vector. What front-end sees as lobj[i] is really lobj[lobjectsNoJava[i]];

  // This list is constructed every time GetLoadObjectList() or GetLoadObjectState() is
  // called. Possibility of further optimization by making it more persistent.
  // Only consumer of this list is dbeSetLoadObjectState
  int new_index = 0;
  if (dbev->lobjectsNoJava == NULL)
    dbev->lobjectsNoJava = new Vector<int>(1);
  else
    dbev->lobjectsNoJava->reset ();

  Vec_loop (LoadObject*, lobjs, index, lo)
  {
    // Set 0, 1, or 2 for show/hide/api
    enum LibExpand expand = dbev->get_lo_expand (lo->seg_idx);

    lo_name = lo->get_name ();
    if (lo_name != NULL)
      {
        size_t len = strlen (lo_name);
        if (len > 7 && streq (lo_name + len - 7, NTXT (".class>")))
          isJava->store (new_index, 1);
        else
          isJava->store (new_index, 0);
      }
    else
      isJava->store (new_index, 0);
    dbev->lobjectsNoJava->append (index);

    names->store (new_index, dbe_sprintf (NTXT ("%s"), lo_name));
    states->store (new_index, (int) expand);
    indices->store (new_index, (int) lo->seg_idx);
    paths->store (new_index, dbe_sprintf (NTXT ("%s"), lo->get_pathname ()));
    new_index++;
  }
  Vector<void*> *res = new Vector<void*>(5);
  res->store (0, names);
  res->store (1, states);
  res->store (2, indices);
  res->store (3, paths);
  res->store (4, isJava);
  delete lobjs;
  return res;
}

Vector<int> *
dbeGetLoadObjectState (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<LoadObject*> *lobjs = dbeSession->get_text_segments ();
  int size = lobjs->size ();

  // Initialize Java boolean array
  Vector<int> *states = new Vector<int>(size);
  char *lo_name;

  // lobjectsNoJava is a trimmed list of indices provided to front-end skipping the Java
  // classes. lobjectsNoJava preserves the mapping of the index into the complete lobjs
  // vector. What front-end sees as lobj[i] is really lobj[lobjectsNoJava[i]];

  // This list is constructed every time GetLoadObjectList() or GetLoadObjectState() is
  // called. Possibility of further optimization by making it more persistent.
  // Only consumer of this list is dbeSetLoadObjectState
  int new_index = 0;
  if (dbev->lobjectsNoJava == NULL)
    dbev->lobjectsNoJava = new Vector<int>(1);
  else
    dbev->lobjectsNoJava->reset ();

  // Get load object states
  int index;
  LoadObject *lo;

  Vec_loop (LoadObject*, lobjs, index, lo)
  {
    // Set 0, 1, or 2 for show/hide/api
    lo_name = lo->get_name ();
    if (lo_name != NULL)
      {
        size_t len = strlen (lo_name);
        if (len > 7 && streq (lo_name + len - 7, NTXT (".class>")))
          continue;
      }
    else
      dbev->lobjectsNoJava->append (index);

    enum LibExpand expand = dbev->get_lo_expand (lo->seg_idx);
    states->store (new_index, (int) expand);
    new_index++;
  }
  delete lobjs;
  return states;
}

// Set load object states
void
dbeSetLoadObjectState (int dbevindex, Vector<int> *selected)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<LoadObject*> *lobjs = dbeSession->get_text_segments ();

  int index;
  bool changed = false;

  LoadObject *lo;
  int new_index = 0;
  dbev->setShowAll ();
  Vec_loop (LoadObject*, lobjs, index, lo)
  {
    if (dbev->lobjectsNoJava != NULL)
      {
        // This loadobject is a java class and was skipped
        if (dbev->lobjectsNoJava->fetch (new_index) != index)
          continue;
      }
    // Get array of settings
    enum LibExpand expand = (enum LibExpand) selected->fetch (new_index);
    if (expand == LIBEX_HIDE)
      {
        dbev->resetShowAll ();
        dbeSession->set_lib_visibility_used ();
      }
    changed = changed | dbev->set_libexpand (lo->get_pathname (), expand);
    new_index++;
  }
  delete lobjs;
  if (changed == true)
    {
      dbev->setShowHideChanged ();
      dbev->update_lo_expands ();
    }

  return;
}

// Reset load object states
void
dbeSetLoadObjectDefaults (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_libdefaults ();
}

// Get  Machine model
Vector<char*>*
dbeGetCPUVerMachineModel (int dbevindex)
{
  Vector<char*>* table = new Vector<char*>();
  DbeView *dbev = dbeSession->getView (dbevindex);
  char * mach_model = dbev->get_settings ()->get_machinemodel ();
  if (mach_model != NULL)
    {
      table->append (mach_model);
      return table;
    }
  int grsize = dbeSession->expGroups->size ();
  for (int j = 0; j < grsize; j++)
    {
      ExpGroup *gr = dbeSession->expGroups->fetch (j);
      Vector<Experiment*> *exps = gr->exps;
      for (int i = 0, sz = exps->size (); i < sz; i++)
        {
          Experiment *exp = exps->fetch (i);
          char *model = exp->machinemodel;
          if (model != NULL)
            table->append (dbe_strdup (model));
        }
    }
  return table;
}

// automatically load machine model if applicable
void
dbeDetectLoadMachineModel (int dbevindex)
{
  if (dbeSession->is_datamode_available ())
    {
      char *model = dbeGetMachineModel ();
      if (model == NULL)
        {
          Vector<char*>* models = dbeGetCPUVerMachineModel (dbevindex);
          char * machineModel = NTXT ("generic");
          if (models->size () > 0)
            {
              machineModel = models->get (0);
              for (int i = 1; i < models->size (); i++)
                {
                  if (strncmp (models->get (i), machineModel, strlen (machineModel)) == 0)
                    {
                      machineModel = NTXT ("generic");
                      break;
                    }
                }
              dbeLoadMachineModel (machineModel);
            }
          delete models;
        }
    }
}

// Managing Memory Objects
char *
dbeDefineMemObj (char *name, char *index_expr, char *machinemodel,
                 char *sdesc, char *ldesc)
{
  return MemorySpace::mobj_define (name, index_expr, machinemodel, sdesc, ldesc);
}

char *
dbeDeleteMemObj (char *name)
{
  return MemorySpace::mobj_delete (name);
}

Vector<void*> *
dbeGetMemObjects (int /*dbevindex*/)
{
  Vector<void*> *res = MemorySpace::getMemObjects ();
  return res;
}

// Managing machine model
char *
dbeLoadMachineModel (char *name)
{
  return dbeSession->load_mach_model (name);
}

char *
dbeGetMachineModel ()
{
  return dbeSession->get_mach_model ();
}

Vector <char *> *
dbeListMachineModels ()
{
  return dbeSession->list_mach_models ();
}

// Managing Index Objects
char *
dbeDefineIndxObj (char *name, char *index_expr, char *sdesc, char *ldesc)
{
  return dbeSession->indxobj_define (name, NULL, index_expr, sdesc, ldesc);
}

Vector<void*> *
dbeGetIndxObjDescriptions (int /*dbevindex*/)
{
  Vector<void*> *res = dbeSession->getIndxObjDescriptions ();
  return res;
}

Vector<void*> *
dbeGetCustomIndxObjects (int /*dbevindex*/)
{
  Vector<void*> *res = dbeSession->getCustomIndxObjects ();
  return res;
}

void
dbeSetSelObj (int dbevindex, Obj sel_obj_or_ind, int type, int subtype)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable *sel_obj;
  Hist_data *data;
  int sel_ind = (int) sel_obj_or_ind;

  switch (type)
    {
    case DSP_FUNCTION:
      data = dbev->func_data;
      break;
    case DSP_LINE:
      data = dbev->line_data;
      break;
    case DSP_PC:
      data = dbev->pc_data;
      break;
    case DSP_CALLER:
      data = dbev->callers;
      break;
    case DSP_CALLEE:
      data = dbev->callees;
      break;
    case DSP_SOURCE:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
      data = dbev->dis_data;
      break;
    case DSP_DLAYOUT:
      data = dbev->dlay_data;
      if (data == NULL)
        {
          dbev->sel_binctx = NULL;
          return;
        }
      if (sel_ind >= 0 && sel_ind < dbev->dlay_data->size ())
        dbev->sel_dobj = dbev->dlay_data->fetch (sel_ind)->obj;
      return;
    case DSP_DATAOBJ:
      data = dbev->dobj_data;
      if (data == NULL)
        {
          dbev->sel_binctx = NULL;
          return;
        }
      if (sel_ind >= 0 && sel_ind < dbev->dobj_data->size ())
        dbev->sel_dobj = dbev->dobj_data->fetch (sel_ind)->obj;
      return;
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      dbev->set_indxobj_sel (subtype, sel_ind);
      sel_obj = dbev->get_indxobj_sel (subtype);
      if (sel_obj && sel_obj->get_type () == Histable::INDEXOBJ)
        dbev->set_sel_obj (((IndexObject*) sel_obj)->get_obj ());
      return;
    case DSP_SOURCE_V2:
    case DSP_DISASM_V2:
    case DSP_TIMELINE:
    case DSP_LEAKLIST:
    case DSP_RACES:
    case DSP_DEADLOCKS:
    case DSP_DUALSOURCE:
    case DSP_SOURCE_DISASM:
    case DSP_IOACTIVITY:
    case DSP_IOVFD:
    case DSP_IOCALLSTACK:
    case DSP_HEAPCALLSTACK:
    case DSP_MINICALLER:
      dbev->set_sel_obj ((Histable *) sel_obj_or_ind);
      return;
    default:
      // abort();
      return;
    }
  if (type != DSP_SOURCE && type != DSP_DISASM && type != DSP_SOURCE_V2
      && type != DSP_DISASM_V2)
    dbev->sel_binctx = NULL;

  if (data == NULL || data->get_status () != Hist_data::SUCCESS
      || sel_ind >= data->size ())
    return;

  if (sel_ind >= 0 && sel_ind < data->size ())
    dbev->set_sel_obj (data->fetch (sel_ind)->obj);
}

void
dbeSetSelObjV2 (int dbevindex, uint64_t id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->set_sel_obj (dbeSession->findObjectById (id));
}

Obj
dbeGetSelObj (int dbevindex, int type, int subtype)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  Histable *sel_obj = NULL;
  switch (type)
    {
    case DSP_FUNCTION:
      sel_obj = dbev->get_sel_obj (Histable::FUNCTION);
      break;
    case DSP_LINE:
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      sel_obj = dbev->get_sel_obj (Histable::LINE);
      break;
    case DSP_PC:
    case DSP_DISASM:
    case DSP_DISASM_V2:
      sel_obj = dbev->get_sel_obj (Histable::INSTR);
      break;
    case DSP_SRC_FILE:
      sel_obj = dbev->get_sel_obj (Histable::SOURCEFILE);
      break;
    case DSP_DATAOBJ:
    case DSP_DLAYOUT:
      if (dbev->sel_dobj)
        sel_obj = dbev->sel_dobj->convertto (Histable::DOBJECT);
      break;
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      sel_obj = dbev->get_indxobj_sel (subtype);
      break;
    default:
      abort ();
    }
  Dprintf (DEBUG_DBE, NTXT ("### dbeGetSelObj: Dbe.cc:%d %s (%d) returns %s\n"),
           __LINE__, dsp_type_to_string (type), type, sel_obj ? sel_obj->dump () : "NULL");
  return (Obj) sel_obj;
}

Obj
dbeConvertSelObj (Obj obj, int type)
{
  Histable *sel_obj = (Histable *) obj;
  Dprintf (DEBUG_DBE, NTXT ("### dbeConvertSelObj: Dbe.cc:%d %s (%d) sel_obj=%s\n"),
           __LINE__, dsp_type_to_string (type), type, sel_obj ? sel_obj->dump ()
          : "NULL");
  if (sel_obj == NULL)
    return (Obj) NULL;
  switch (type)
    {
    case DSP_FUNCTION:
      return (Obj) sel_obj->convertto (Histable::FUNCTION);
    case DSP_LINE:
      return (Obj) sel_obj->convertto (Histable::LINE);
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      {
        SourceFile* srcCtx = NULL;
        if (sel_obj->get_type () == Histable::INSTR)
          {
            DbeInstr* dbei = (DbeInstr *) sel_obj;
            srcCtx = (SourceFile*) dbei->convertto (Histable::SOURCEFILE);
          }
        else if (sel_obj->get_type () == Histable::LINE)
          {
            DbeLine * dbel = (DbeLine *) sel_obj;
            srcCtx = dbel->sourceFile;
          }
        sel_obj = sel_obj->convertto (Histable::LINE, srcCtx);
        Dprintf (DEBUG_DBE, NTXT ("### dbeConvertSelObj: Dbe.cc:%d %s (%d) returns %s\n"),
                 __LINE__, dsp_type_to_string (type), type, sel_obj ? sel_obj->dump () : "NULL");
        if (sel_obj && sel_obj->get_type () == Histable::LINE)
          {
            DbeLine * dbel = (DbeLine *) sel_obj;
            return (Obj) dbel->dbeline_base;
          }
        return (Obj) sel_obj->convertto (Histable::LINE, srcCtx);
      }
    case DSP_PC:
    case DSP_DISASM:
    case DSP_DISASM_V2:
      return (Obj) sel_obj->convertto (Histable::INSTR);
    case DSP_SRC_FILE:
      return (Obj) sel_obj->convertto (Histable::SOURCEFILE);
    default:
      abort ();
    }
  return (Obj) NULL;
}

uint64_t
dbeGetSelObjV2 (int dbevindex, char *typeStr)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable *obj = NULL;
  if (typeStr != NULL)
    {
      if (streq (typeStr, NTXT ("FUNCTION")))
        obj = dbev->get_sel_obj (Histable::FUNCTION);
      else if (streq (typeStr, NTXT ("INSTRUCTION")))
        obj = dbev->get_sel_obj (Histable::INSTR);
      else if (streq (typeStr, NTXT ("SOURCELINE")))
        obj = dbev->get_sel_obj (Histable::LINE);
      else if (streq (typeStr, NTXT ("SOURCEFILE")))
        obj = dbev->get_sel_obj (Histable::SOURCEFILE);
    }
  Dprintf (DEBUG_DBE, NTXT ("### dbeGetSelObjV2: Dbe.cc:%d %s returns %s\n"),
           __LINE__, STR (typeStr), obj ? obj->dump () : "NULL");
  return obj != NULL ? obj->id : (uint64_t) - 1;
}

Vector<uint64_t> *
dbeGetSelObjsIO (int dbevindex, Vector<uint64_t> *ids, int type)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<uint64_t> *res = NULL;
  Vector<uint64_t> *result = new Vector<uint64_t>();
  for (int i = 0; i < ids->size (); i++)
    {
      res = dbeGetSelObjIO (dbevindex, ids->fetch (i), type);
      if (res != NULL)
        {
          result->addAll (res);
          delete res;
        }
    }
  return result;
}

Vector<uint64_t> *
dbeGetSelObjIO (int dbevindex, uint64_t id, int type)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable *obj = NULL;
  Vector<uint64_t> *res = NULL;
  int size = 0;
  switch (type)
    {
    case DSP_IOACTIVITY:
      obj = dbev->get_sel_obj_io (id, Histable::IOACTFILE);
      size = obj != NULL ? ((FileData*) obj)->getVirtualFds ()->size () : 0;
      if (size)
        {
          res = new Vector<uint64_t>();
          Vector<int64_t> *vfds = ((FileData*) obj)->getVirtualFds ();
          for (int i = 0; i < size; i++)
            res->append (vfds->fetch (i));
        }
      break;
    case DSP_IOVFD:
      obj = dbev->get_sel_obj_io (id, Histable::IOACTVFD);
      if (obj)
        {
          res = new Vector<uint64_t>();
          res->append (obj->id);
        }
      break;
    case DSP_IOCALLSTACK:
      obj = dbev->get_sel_obj_io (id, Histable::IOCALLSTACK);
      if (obj)
        {
          Vector<Obj> *instrs = dbeGetStackPCs (dbevindex, obj->id);
          if (instrs == NULL)
            return NULL;
          int stsize = instrs->size ();
          res = new Vector<uint64_t>(stsize);
          for (int i = 0; i < stsize; i++)
            {
              Histable *objFunc = (DbeInstr*) (instrs->fetch (i));
              if (objFunc->get_type () != Histable::LINE)
                {
                  objFunc = objFunc->convertto (Histable::FUNCTION);
                  res->insert (0, objFunc->id);
                }
            }
          delete instrs;
        }
      break;
    default:
      break;
    }
  return res;
}

uint64_t
dbeGetSelObjHeapTimestamp (int dbevindex, uint64_t id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable *obj = NULL;
  uint64_t res = 0;
  Vector<uint64_t> *peakStackIds;
  Vector<hrtime_t> *peakTimestamps;

  // Find and return the timestamp for the peak
  bool foundPeakId = false;
  if (id > 0)
    {
      obj = dbev->get_sel_obj_heap (0);
      if (obj != NULL)
        {
          peakStackIds = ((HeapData*) obj)->getPeakStackIds ();
          peakTimestamps = ((HeapData*) obj)->getPeakTimestamps ();
          for (int i = 0; i < peakStackIds->size (); i++)
            {
              if (id == peakStackIds->fetch (i))
                {
                  res = peakTimestamps->fetch (i);
                  foundPeakId = true;
                  break;
                }
            }
        }
    }

  // Return the first timestamp for the peak
  // if the callstack id is zero or it
  // doesn't match with the peak stack id
  if (id == 0 || !foundPeakId)
    {
      obj = dbev->get_sel_obj_heap (0);
      res = obj != NULL ? ((HeapData*) obj)->getPeakTimestamps ()->fetch (0) : 0;
    }
  return res;
}

int
dbeGetSelObjHeapUserExpId (int dbevindex, uint64_t id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable *obj = NULL;
  int res = 0;
  obj = dbev->get_sel_obj_heap (id);
  res = obj != NULL ? ((HeapData*) obj)->getUserExpId () : 0;
  return res;
}

//
// Get index of selected function/object
//
int
dbeGetSelIndex (int dbevindex, Obj sel_obj, int type, int subtype)
{
  Hist_data *data;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  switch (type)
    {
    case DSP_FUNCTION:
      data = dbev->func_data;
      break;
    case DSP_LINE:
      data = dbev->line_data;
      break;
    case DSP_PC:
      data = dbev->pc_data;
      break;
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      data = dbev->dis_data;
      break;
    case DSP_DLAYOUT:
      data = dbev->dlay_data;
      break;
    case DSP_DATAOBJ:
      data = dbev->dobj_data;
      break;
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      data = dbev->get_indxobj_data (subtype);
      break;
    default:
      data = NULL;
      break;
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return -1;

  Histable *chk_obj = (Histable *) sel_obj;
  Vector<Hist_data::HistItem*> *histItems = data->get_hist_items ();
  if (histItems == NULL || chk_obj == NULL)
    return -1;
  for (int i = 0, sz = histItems->size (); i < sz; i++)
    {
      if (histItems->get (i)->obj == chk_obj)
        return i;
      if (histItems->get (i)->obj == NULL)
        continue;
      if (histItems->get (i)->obj->get_type () == Histable::LINE
          && chk_obj->get_type () == Histable::LINE)
        {
          if (((DbeLine*) histItems->get (i)->obj)->convertto (Histable::FUNCTION)
              == ((DbeLine*) chk_obj)->convertto (Histable::FUNCTION)
              && ((DbeLine*) histItems->get (i)->obj)->lineno
              == ((DbeLine*) chk_obj)->lineno)
            return i;
        }
      else if (histItems->get (i)->obj->get_type () == Histable::INSTR
         && chk_obj->get_type () == Histable::INSTR)
        if (((DbeInstr*) histItems->get (i)->obj)->convertto (Histable::FUNCTION)
            == ((DbeInstr*) chk_obj)->convertto (Histable::FUNCTION)
            && ((DbeInstr*) histItems->get (i)->obj)->addr
            == ((DbeInstr*) chk_obj)->addr)
          return i;
    }

  Histable *chk_obj1 = NULL;
  switch (type)
    {
    case DSP_FUNCTION:
      chk_obj1 = chk_obj->convertto (Histable::FUNCTION);
      break;
    case DSP_LINE:
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      chk_obj1 = chk_obj->convertto (Histable::LINE);
      break;
    case DSP_PC:
    case DSP_DISASM:
    case DSP_DISASM_V2:
      chk_obj1 = chk_obj->convertto (Histable::INSTR);
      break;
    }
  if (chk_obj1 && chk_obj != chk_obj1)
    for (int i = 0, sz = histItems->size (); i < sz; i++)
      if (histItems->get (i)->obj == chk_obj1)
        return i;

  if (type == DSP_LINE)
    {
      for (int i = 0, sz = histItems->size (); i < sz; i++)
        if (histItems->get (i)->obj != NULL
            && chk_obj->convertto (Histable::FUNCTION)
            == histItems->get (i)->obj->convertto (Histable::FUNCTION))
          return i;
    }
  else if (type == DSP_PC)
    {
      for (int i = 0, sz = histItems->size (); i < sz; i++)
        if (histItems->get (i)->obj != NULL
            && (histItems->get (i)->obj)->convertto (Histable::FUNCTION)
            == (chk_obj)->convertto (Histable::FUNCTION)
            && ((DbeLine*) histItems->get (i)->obj->convertto (Histable::LINE))->lineno
            == ((DbeLine*) chk_obj->convertto (Histable::LINE))->lineno)
          return i;
      for (int i = 0, sz = histItems->size (); i < sz; i++)
        if (histItems->get (i)->obj != NULL
            && (histItems->get (i)->obj)->convertto (Histable::FUNCTION)
            == (chk_obj)->convertto (Histable::FUNCTION))
          return i;
    }

  // If we clicked on an mfunction line in the called-by call mini in user mode for omp
  // we might not find that function in func data
  if (dbev->isOmpDisMode () && type == DSP_FUNCTION)
    {
      int p = dbeGetSelIndex (dbevindex, sel_obj, DSP_DISASM, subtype);
      if (p != -1)
        return p;
    }
  return -1;
}

// Print data
//
char *
dbePrintData (int dbevindex, int type, int subtype, char *printer,
              char *fname, FILE *outfile)
{
  Histable *current_obj;
  Function *func;
  Module *module;
  MetricList *mlist_orig;
  bool header;
  Print_params params;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();

  // Set print parameters
  if (printer != NULL)
    {
      params.dest = DEST_PRINTER;
      params.name = printer;
    }
  else if (outfile != NULL)
    {
      params.dest = DEST_OPEN_FILE;
      params.openfile = outfile;
      params.name = NULL;
    }
  else
    {
      params.dest = DEST_FILE;
      params.name = fname;
      if (*(params.name) == '\0')
        {
          free (params.name);
          return dbe_strdup (GTXT ("Please enter the name of the file to which to print"));
        }
    }
  params.ncopies = 1;
  if (outfile != NULL)
    header = false;
  else
    header = !(type == DSP_SOURCE || type == DSP_SOURCE_V2 || type == DSP_DISASM_V2);

  params.header = header;

  // figure out what kind of metrics to use
  if (type == DSP_SELF || type == DSP_CALLER || type == DSP_CALLEE
      || type == DSP_CALLTREE)
    mlist_orig = dbev->get_metric_list (MET_CALL);
  else if (type == DSP_DATAOBJ || type == DSP_DLAYOUT || type == DSP_MEMOBJ)
    mlist_orig = dbev->get_metric_list (MET_DATA);
  else if (type == DSP_INDXOBJ)
    mlist_orig = dbev->get_metric_list (MET_INDX);
  else if (type == DSP_IOACTIVITY || type == DSP_IOVFD
           || type == DSP_IOCALLSTACK)
    mlist_orig = dbev->get_metric_list (MET_IO);
  else if (type == DSP_HEAPCALLSTACK)
    mlist_orig = dbev->get_metric_list (MET_HEAP);
  else
    mlist_orig = dbev->get_metric_list (MET_NORMAL);

  // make a compacted version of the input list
  // the list will either be moved to the generated data,
  //   or freed below if it wasn't needed
  MetricList *mlist = new MetricList (mlist_orig);
  Hist_data *data = NULL;
  er_print_common_display *cd = NULL;
  int ix;
  // Set data
  switch (type)
    {
    case DSP_FUNCTION:
    case DSP_LINE:
    case DSP_PC:
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
    case DSP_DATAOBJ:
      data = dbev->get_hist_data (mlist,
                                  ((type == DSP_FUNCTION) ? Histable::FUNCTION :
                                   (type == DSP_LINE) ? Histable::LINE :
                                   (type == DSP_PC) ? Histable::INSTR :
                                   (type == DSP_INDXOBJ) ? Histable::INDEXOBJ :
                                   (type == DSP_MEMOBJ) ? Histable::MEMOBJ
                                   : Histable::DOBJECT),
                                  subtype, Hist_data::ALL);
      if (data->get_status () != Hist_data::SUCCESS)
        return DbeView::status_str (DbeView::DBEVIEW_NO_DATA); // no strdup()

      cd = new er_print_histogram (dbev, data, mlist, MODE_LIST,
                                   dbev->get_limit (),
                                   mlist->get_sort_name (), NULL, true, true);
      break;
    case DSP_DLAYOUT:
      {
        data = dbev->get_hist_data (mlist, Histable::DOBJECT, 0, Hist_data::LAYOUT);
        if (data->get_status () != Hist_data::SUCCESS)
          return DbeView::status_str (DbeView::DBEVIEW_NO_DATA); // no strdup()
        cd = new er_print_histogram (dbev, data, mlist, MODE_ANNOTATED,
                                     dbev->get_thresh_dis (),
                                     mlist->get_sort_name (), NULL, true, true);
        break;
      }

      // source and disassembly
    case DSP_SOURCE:
    case DSP_DISASM:
    case DSP_SOURCE_V2:
    case DSP_DISASM_V2:
      if (dbev->sel_obj == NULL)
        return NULL;
      current_obj = dbev->sel_obj->convertto (Histable::FUNCTION);
      if (current_obj->get_type () != Histable::FUNCTION)
        return dbe_strdup (GTXT ("Not a real function; no source or disassembly available."));
      func = (Function*) current_obj->convertto (Histable::FUNCTION);
      if (func->flags & FUNC_FLAG_SIMULATED)
        return dbe_strdup (GTXT ("Not a real function; no source or disassembly available."));
      if (func->get_name () == NULL)
        return dbe_strdup (GTXT ("Source location not recorded in experiment"));
      module = func->module;
      if (module == NULL || module->get_name () == NULL)
        return dbe_strdup (GTXT ("Object name not recorded in experiment"));
      ix = module->loadobject->seg_idx;
      if (dbev->get_lo_expand (ix) == LIBEX_HIDE)
        return dbe_strdup (GTXT ("No source or disassembly available for hidden object"));
      cd = new er_print_histogram (dbev, dbev->func_data, mlist, MODE_ANNOTATED,
                                   type == DSP_DISASM || type == DSP_DISASM_V2,
                                   mlist->get_sort_name (),
                                   func, false, false);
      break;

      // callers-callees
    case DSP_SELF:
    case DSP_CALLER:
    case DSP_CALLEE:
      if (dbev->sel_obj == NULL)
        return NULL;
      current_obj = dbev->sel_obj->convertto (Histable::FUNCTION);
      cd = new er_print_histogram (dbev, dbev->func_data, mlist, MODE_GPROF, 1,
                                   mlist->get_sort_name (), current_obj,
                                   false, false);
      break;

      // statistics; this won't use the metric list copied above, so delete it
    case DSP_STATIS:
      cd = new er_print_experiment (dbev, 0, dbeSession->nexps () - 1,
                                    true, true, true, true, false);
      delete mlist;
      break;
    case DSP_EXP:
      cd = new er_print_experiment (dbev, 0, dbeSession->nexps () - 1,
                                    true, true, false, false, false);
      delete mlist;
      break;
    case DSP_LEAKLIST:
      cd = new er_print_leaklist (dbev, true, true, dbev->get_limit ());
      delete mlist;
      break;
    case DSP_HEAPCALLSTACK:
      cd = new er_print_heapactivity (dbev, Histable::HEAPCALLSTACK, false,
                                      dbev->get_limit ());
      delete mlist;
      break;
    case DSP_IOACTIVITY:
      cd = new er_print_ioactivity (dbev, Histable::IOACTFILE, false,
                                    dbev->get_limit ());
      delete mlist;
      break;
    case DSP_IOVFD:
      cd = new er_print_ioactivity (dbev, Histable::IOACTVFD, false,
                                    dbev->get_limit ());
      delete mlist;
      break;

      // the io call stack
    case DSP_IOCALLSTACK:
      cd = new er_print_ioactivity (dbev, Histable::IOCALLSTACK, false,
                                    dbev->get_limit ());
      delete mlist;
      break;

      // some unknown panel -- return an error string
    default:
      delete mlist;
      return dbe_strdup (GTXT ("Print not available"));
    }

  // Start printing
  char *buf = NULL;

  // first open the file/device/whatever
  if (cd->open (&params) == 0)
    {
      // now call the actual print routine
      cd->data_dump ();
      if (params.dest == DEST_PRINTER)
        {
          if (streq ((char *) params.name, NTXT ("-")))
            {
              // Special case - return report to the GUI
              int maxbytes = 2 * 1024 * 1024; // IPC large buffer limit
              char *report = cd->get_output (maxbytes);
              delete data;
              delete cd;
              return report; // TEMPORARY
            }
        }
      if (cd->print_output () == false)
        buf = dbe_sprintf (NTXT ("%s: %s"),
                           GTXT ("Unable to submit print request to"),
                           params.name);
    }
  else
    // if unable to set up the print, return an error
    buf = dbe_sprintf (NTXT ("%s: %s"),
                       GTXT ("Unable to open file"),
                       params.name);

  // dbe_free((void *) params.name); XXX when should this happen?
  if (data)
    if (data->isViewOwned () == false)
      delete data;
  delete cd;
  return buf;
}

// Set limit for print data
//
char *
dbeSetPrintLimit (int dbevindex, int limit)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  return (dbev->set_limit (limit));
}

// get limit for print data
int
dbeGetPrintLimit (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  int limit = dbev->get_limit ();
  return limit;
}

// set printmode for data
char *
dbeSetPrintMode (int dbevindex, char * pmode)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  char *r = dbev->set_printmode (pmode);
  return r;
}

// get printmode for data
int
dbeGetPrintMode (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  return (dbev->get_printmode ());
}

// get printmode for data
char *
dbeGetPrintModeString (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  return ( dbev->get_printmode_str ());
}

// get print delimiter for csv data
char
dbeGetPrintDelim (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  return (dbev->get_printdelimiter ());
}

// Set Source/Object/Load-Object file names
static void
set_file_names (Function *func, char *names[3])
{
  Module *module = func->module;
  LoadObject *loadobject = module->loadobject;
  if (loadobject == NULL)
    loadobject = dbeSession->get_Unknown_LoadObject ();
  free (names[0]);
  free (names[1]);
  free (names[2]);
  SourceFile *sf = func->getDefSrc ();
  char *src_name = sf->dbeFile->get_location_info ();
  DbeFile *df = module->dbeFile;
  if (df == NULL || (df->filetype & DbeFile::F_JAVACLASS) == 0)
    df = module->loadobject->dbeFile;
  char *lo_name = df->get_location_info ();
  char *dot_o_name = lo_name;
  if (module->dot_o_file)
    dot_o_name = module->dot_o_file->dbeFile->get_location_info ();
  names[0] = dbe_sprintf (NTXT ("%s: %s"), GTXT ("Source File"), src_name);
  names[1] = dbe_sprintf (NTXT ("%s: %s"), GTXT ("Object File"), dot_o_name);
  names[2] = dbe_sprintf (NTXT ("%s: %s"), GTXT ("Load Object"), lo_name);
}

// dbeSetFuncData
//      Master function to generate all Tab data for the analyzer
//      Returns the index of the selected item in the specified list
//
// After calling it to set up, the Analyzer calls dbeGetFuncList
//      to format the generated data and return the table
//      Most of the data is destined for a JTable
//
int
dbeSetFuncData (int dbevindex, Obj sel_obj, int type, int subtype)
{
  MetricList *_mlist;
  Histable *org_obj;
  Hist_data *data = NULL;
  int index, sel_index;
  Function *func;
  char *name;
  int ix;

  DbeView *dbev = dbeSession->getView (dbevindex);
  sel_index = -1;
  dbev->resetOmpDisMode ();
  dbev->error_msg = dbev->warning_msg = NULL;

  // get metric list, make a compact duplicate
  _mlist = dbev->get_metric_list (MET_NORMAL);
  MetricList *mlist = new MetricList (_mlist);

  // Remove old function/obj list data & Get new function/obj list data
  org_obj = (Histable *) sel_obj;

  // Figure out which "function" data is being asked for, i.e.,
  //    which of the analyzer displays is asking for data
  switch (type)
    {
      // the various tables: functions, lines, PCs, DataObjects, IndexObjects
    case DSP_FUNCTION:
    case DSP_LINE:
    case DSP_PC:
    case DSP_DATAOBJ:
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      switch (type)
        {
        case DSP_FUNCTION:
          if (dbev->func_data)
            delete dbev->func_data;
          dbev->func_data = data = dbev->get_hist_data (mlist,
                                   Histable::FUNCTION, subtype, Hist_data::ALL);
          break;
        case DSP_LINE:
          if (dbev->line_data)
            delete dbev->line_data;
          dbev->line_data = data = dbev->get_hist_data (mlist,
                                       Histable::LINE, subtype, Hist_data::ALL);
          break;
        case DSP_PC:
          if (dbev->pc_data)
            delete dbev->pc_data;
          dbev->pc_data = data = dbev->get_hist_data (mlist,
                                      Histable::INSTR, subtype, Hist_data::ALL);
          break;
        case DSP_DATAOBJ:
          if (dbev->dobj_data)
            delete dbev->dobj_data;
          mlist = dbev->get_metric_list (MET_DATA);
          dbev->dobj_data = data = dbev->get_hist_data (mlist,
                                    Histable::DOBJECT, subtype, Hist_data::ALL);
          break;
        case DSP_MEMOBJ:
          mlist = dbev->get_metric_list (MET_DATA);
          data = dbev->get_hist_data (mlist, Histable::MEMOBJ, subtype,
                                      Hist_data::ALL);
          dbev->indx_data->store (subtype, data);
          break;
        case DSP_INDXOBJ:
          mlist = dbev->get_metric_list (MET_INDX);
          data = dbev->get_hist_data (mlist, Histable::INDEXOBJ, subtype,
                                      Hist_data::ALL);
          dbev->indx_data->store (subtype, data);
          break;
        default:
          break;
        }

      // Set the selection of row item
      if (data->get_status () == Hist_data::SUCCESS)
        {
          // otherwise, look for it
          sel_index = -1;
          if (org_obj)
            {
              Hist_data::HistItem *hi;
              Vec_loop (Hist_data::HistItem*, data->get_hist_items (), index, hi)
              {
                if (hi->obj == org_obj)
                  {
                    sel_index = index;
                    break;
                  }
              }
              if (sel_index == -1 && (type == DSP_LINE || type == DSP_PC))
                {
                  Vec_loop (Hist_data::HistItem*, data->get_hist_items (), index, hi)
                  {
                    name = hi->obj->get_name ();
                    if (strcmp (name, NTXT ("<Total>")) &&
                        strcmp (name, GTXT ("<Unknown>")))
                      {
                        int done = 0;
                        switch (type)
                          {
                          case DSP_LINE:
                            if (org_obj->convertto (Histable::FUNCTION)
                                     == hi->obj->convertto (Histable::FUNCTION))
                              {
                                sel_index = index;
                                done = 1;
                              }
                            break;
                          case DSP_PC:
                            if (hi->obj->convertto (Histable::FUNCTION)
                                == org_obj->convertto (Histable::FUNCTION)
                                && ((DbeLine*) hi->obj->convertto (Histable::LINE))->lineno
                                == ((DbeLine*) org_obj->convertto (Histable::LINE))->lineno)
                              {
                                sel_index = index;
                                done = 1;
                              }
                            break;
                          }
                        if (done)
                          break;
                      }
                  }
                }
              if (sel_index == -1 && type == DSP_PC)
                {
                  Vec_loop (Hist_data::HistItem*, data->get_hist_items (), index, hi)
                  {
                    name = hi->obj->get_name ();
                    if (strcmp (name, NTXT ("<Total>")) &&
                        strcmp (name, GTXT ("<Unknown>")))
                      {
                        int done = 0;
                        if (hi->obj->convertto (Histable::FUNCTION) ==
                            org_obj->convertto (Histable::FUNCTION))
                          {
                            sel_index = index;
                            done = 1;
                          }
                        if (done)
                          break;
                      }
                  }
                }
            }
          if (sel_index == -1)
            {
              Hist_data::HistItem *hi;
              Vec_loop (Hist_data::HistItem*, data->get_hist_items (), index, hi)
              {
                name = hi->obj->get_name ();
                if (strcmp (name, NTXT ("<Total>")) &&
                    strcmp (name, GTXT ("<Unknown>")))
                  {
                    sel_index = index;
                    break;
                  }
              }
            }
        }
      else
        dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_DATA);
      return sel_index;
      // the end of the code for the regular tables

      // Data Layout
    case DSP_DLAYOUT:
      if (dbev->dlay_data)
        delete dbev->dlay_data;
      dbev->marks->reset ();
      mlist = dbev->get_metric_list (MET_DATA);

      // initial dobj list ...
      data = dbev->get_hist_data (mlist, Histable::DOBJECT, subtype,
                                  Hist_data::LAYOUT);
      // .. provides metric data for layout
      dbev->dlay_data = data = dbev->get_data_space ()->get_layout_data (data,
                                          dbev->marks, dbev->get_thresh_dis ());
      if (data->get_status () != Hist_data::SUCCESS)
        dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_DATA);
      return sel_index;

      // Source or disassembly
    case DSP_SOURCE_V2:
    case DSP_DISASM_V2:
    case DSP_SOURCE:
    case DSP_DISASM:
      {
        if (org_obj == NULL)
          {
            dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_SEL_OBJ);
            return sel_index;
          }
        if (org_obj->get_type () != Histable::FUNCTION)
          {
            dbev->error_msg = dbe_strdup (
             GTXT ("Not a real function; no source or disassembly available."));
            return sel_index;
          }
        func = (Function *) org_obj;
        if (func->flags & FUNC_FLAG_SIMULATED)
          {
            dbev->error_msg = dbe_strdup (
             GTXT ("Not a real function; no source or disassembly available."));
            return sel_index;
          }
        if (func->get_name () == NULL)
          {
            dbev->error_msg = dbe_strdup (
                           GTXT ("Source location not recorded in experiment"));
            return sel_index;
          }
        Module *module = func->module;
        if ((module == NULL) || (module->get_name () == NULL))
          {
            dbev->error_msg = dbe_strdup (
                               GTXT ("Object name not recorded in experiment"));
            return sel_index;
          }
        ix = module->loadobject->seg_idx;
        if (dbev->get_lo_expand (ix) == LIBEX_HIDE)
          {
            dbev->error_msg = dbe_strdup (
                 GTXT ("No source or disassembly available for hidden object"));
            return sel_index;
          }

        if ((type == DSP_DISASM || type == DSP_DISASM_V2)
             && dbev->get_view_mode () == VMODE_USER
            && dbeSession->is_omp_available ())
          dbev->setOmpDisMode ();

        dbev->marks->reset ();
        SourceFile *srcContext = NULL;
        switch (dbev->sel_obj->get_type ())
          {
          case Histable::FUNCTION:
            {
              Function *f = (Function *) dbev->sel_obj;
              srcContext = f->getDefSrc ();
              dbev->sel_binctx = f->module;
              break;
            }
          case Histable::LINE:
            {
              DbeLine *dl = (DbeLine *) dbev->sel_obj;
              srcContext = dl->sourceFile;
              Function *f = dl->func;
              if (f)
                dbev->sel_binctx = f;
              break;
            }
          case Histable::INSTR:
            {
              Function *f = (Function *) dbev->sel_obj->convertto (Histable::FUNCTION);
              if (f)
                {
                  dbev->sel_binctx = f;
                  srcContext = f->getDefSrc ();
                }
              break;
            }
          default:
            break;
          }
        mlist = dbev->get_metric_list (MET_SRCDIS);

        // for source and disassembly the name needs to be invisible,
        //      but that's handled in the module code
        if (type == DSP_SOURCE)
          {
            if (dbev->src_data)
              delete dbev->src_data;

            // func_data computation needed for get_totals
            if (dbev->func_data == NULL)
              dbev->func_data = data = dbev->get_hist_data (mlist,
                                   Histable::FUNCTION, subtype, Hist_data::ALL);
            dbev->marks2dsrc->reset ();
            dbev->marks2dsrc_inc->reset ();
            data = dbev->src_data = module->get_data (dbev, mlist,
                          Histable::LINE, dbev->func_data->get_totals ()->value,
                          srcContext, func, dbev->marks,
                          dbev->get_thresh_src (), dbev->get_src_compcom (),
                          dbev->get_src_visible (), dbev->get_hex_visible (),
                          false, false, dbev->marks2dsrc, dbev->marks2dsrc_inc);
            set_file_names (func, dbev->names_src);
            if (srcContext)
              {
                free (dbev->names_src[0]);
                dbev->names_src[0] = dbe_sprintf (GTXT ("Source File: %s"),
                                     srcContext->dbeFile->get_location_info ());
              }
            Obj obj = (Obj) func->convertto (Histable::LINE, srcContext);
            sel_index = dbeGetSelIndex (dbevindex, obj, type, subtype);
          }
        else
          { /* type == DSP_DISASM */
            if (dbev->dis_data)
              delete dbev->dis_data;

            // func_data computation needed for get_totals
            if (dbev->func_data == NULL)
              dbev->func_data = data = dbev->get_hist_data (mlist,
                                  Histable::FUNCTION, subtype, Hist_data::ALL);
            dbev->marks2ddis->reset ();
            dbev->marks2ddis_inc->reset ();
            data = dbev->dis_data = module->get_data (dbev, mlist,
                         Histable::INSTR, dbev->func_data->get_totals ()->value,
                         srcContext, func, dbev->marks, dbev->get_thresh_dis (),
                         dbev->get_dis_compcom (), dbev->get_src_visible (),
                         dbev->get_hex_visible (), dbev->get_func_scope (),
                         false, dbev->marks2ddis, dbev->marks2ddis_inc);
            set_file_names (func, dbev->names_dis);
            if (srcContext)
              {
                free (dbev->names_dis[0]);
                dbev->names_dis[0] = dbe_sprintf (GTXT ("Source File: %s"),
                                    srcContext->dbeFile->get_location_info ());
              }
            Obj obj = (Obj) func->convertto (Histable::INSTR);
            sel_index = dbeGetSelIndex (dbevindex, obj, type, subtype);
          }
        return sel_index;
      }

      // the three cases for caller-callee
    case DSP_SELF:
    case DSP_CALLER:
    case DSP_CALLEE:
      if (org_obj == NULL)
        {
          dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_SEL_OBJ);
          return sel_index;
        }

      // Caller data
      if (dbev->callers)
        delete dbev->callers;
      mlist = dbev->get_metric_list (MET_CALL);
      dbev->callers = dbev->get_hist_data (mlist, Histable::FUNCTION, subtype,
                                           Hist_data::CALLERS, org_obj);
      if (dbev->callers->get_status () != Hist_data::SUCCESS)
        {
          dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_DATA);
          return sel_index;
        }

      // Callee data
      if (dbev->callees)
        delete dbev->callees;
      dbev->callees = dbev->get_hist_data (mlist, Histable::FUNCTION, subtype,
                                           Hist_data::CALLEES, org_obj);
      if (dbev->callees->get_status () != Hist_data::SUCCESS)
        {
          dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_DATA);
          return sel_index;
        }

      // Center Function item
      if (dbev->fitem_data)
        delete dbev->fitem_data;
      dbev->fitem_data = dbev->get_hist_data (mlist, Histable::FUNCTION, subtype,
                                              Hist_data::SELF, org_obj);
      if (dbev->fitem_data->get_status () != Hist_data::SUCCESS)
        {
          dbev->error_msg = DbeView::status_str (DbeView::DBEVIEW_NO_DATA);
          return sel_index;
        }
      return sel_index;
    default:
      abort ();
    }
  return sel_index;
}

Vector<void*>*
dbeGetTotals (int dbevindex, int dsptype, int subtype)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  MetricList *mlist = dbev->get_metric_list (dsptype, subtype);
  Hist_data *data = dbev->get_hist_data (mlist, Histable::FUNCTION, 0,
                                         Hist_data::ALL);
  Hist_data::HistItem *totals = data->get_totals ();
  Vector<void*> *tbl = new Vector<void*>(mlist->size ());
  for (long i = 0, sz = mlist->size (); i < sz; i++)
    {
      Metric *m = mlist->get (i);
      switch (m->get_vtype ())
        {
        case VT_DOUBLE:
          {
            Vector<double> *lst = new Vector<double>(1);
            lst->append (totals->value[i].d);
            tbl->append (lst);
            break;
          }
        case VT_INT:
          {
            Vector<int> *lst = new Vector<int>(1);
            lst->append (totals->value[i].i);
            tbl->append (lst);
            break;
          }
        case VT_LLONG:
        case VT_ULLONG:
        case VT_ADDRESS:
          {
            Vector<long long> *lst = new Vector<long long>(1);
            lst->append (totals->value[i].ll);
            tbl->append (lst);
            break;
          }
        case VT_LABEL:
          {
            Vector<char *> *lst = new Vector<char *>(1);
            Histable::NameFormat nfmt = dbev->get_name_format ();
            lst->append (dbe_strdup (totals->obj->get_name (nfmt)));
            tbl->append (lst);
            break;
          }
        default:
          abort ();
        }
    }
  Vector<void*> *res = new Vector<void*>(2);
  res->append (dbeGetMetricList (mlist));
  res->append (tbl);
  return res;
}

Vector<void*>*
dbeGetHotMarks (int dbevindex, int type)
{
  Vector<void*>* table = new Vector<void*>(2);
  Vector<int>* table0 = new Vector<int> ();
  Vector<int>* table1 = new Vector<int> ();
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    return NULL;

  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      for (int i = 0; i < dbev->marks2dsrc->size (); i++)
        {
          table0->append (dbev->marks2dsrc->fetch (i).index1);
          table1->append (dbev->marks2dsrc->fetch (i).index2);
        }
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      for (int i = 0; i < dbev->marks2ddis->size (); i++)
        {
          table0->append (dbev->marks2ddis->fetch (i).index1);
          table1->append (dbev->marks2ddis->fetch (i).index2);
        }
      break;
    default:
      break;
    }
  table->store (0, table0);
  table->store (1, table1);
  return table;
}

Vector<void*>*
dbeGetHotMarksInc (int dbevindex, int type)
{
  Vector<void*>* table = new Vector<void*>(2);
  Vector<int>* table0 = new Vector<int> ();
  Vector<int>* table1 = new Vector<int> ();
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    return NULL;

  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      for (int i = 0; i < dbev->marks2dsrc_inc->size (); i++)
        {
          table0->append (dbev->marks2dsrc_inc->fetch (i).index1);
          table1->append (dbev->marks2dsrc_inc->fetch (i).index2);
        }
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      for (int i = 0; i < dbev->marks2ddis_inc->size (); i++)
        {
          table0->append (dbev->marks2ddis_inc->fetch (i).index1);
          table1->append (dbev->marks2ddis_inc->fetch (i).index2);
        }
      break;
    default:
      break;
    }
  table->store (0, table0);
  table->store (1, table1);
  return table;
}

Vector<void*>*
dbeGetSummaryHotMarks (int dbevindex, Vector<Obj> *sel_objs, int type)
{
  Vector<void*>* table = new Vector<void*>(2);
  Vector<int>* table0 = new Vector<int> ();
  Vector<int>* table1 = new Vector<int> ();
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    return NULL;
  if (sel_objs == NULL || sel_objs->size () == 0)
    return NULL;

  Hist_data *data;
  Vector<int_pair_t> *marks2d;
  Vector<int_pair_t>* marks2d_inc;
  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      data = dbev->src_data;
      marks2d = dbev->marks2dsrc;
      marks2d_inc = dbev->marks2dsrc_inc;
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      data = dbev->dis_data;
      marks2d = dbev->marks2ddis;
      marks2d_inc = dbev->marks2ddis_inc;
      break;
    default:
      data = NULL;
      marks2d = NULL;
      marks2d_inc = NULL;
      break;
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS
      || marks2d_inc == NULL || marks2d == NULL)
    return NULL;

  MetricList *orig_mlist = data->get_metric_list ();
  MetricList *prop_mlist = new MetricList (dbev->get_metric_ref (MET_NORMAL));
  if (prop_mlist && dbev->comparingExperiments ())
    prop_mlist = dbev->get_compare_mlist (prop_mlist, 0);
  Metric *mitem;
  int index, index2;
  index2 = 0;
  Vec_loop (Metric*, prop_mlist->get_items (), index, mitem)
  {
    if (mitem->get_subtype () == Metric::STATIC)
      continue;

    for (int i = 0; i < marks2d_inc->size (); i++)
      {
        int found = 0;
        for (int j = 0; j < sel_objs->size (); j++)
          {
            int sel_index = (int) sel_objs->fetch (j);
            int marked_index = marks2d_inc->fetch (i).index1;
            if (sel_index == marked_index)
              {
                found = 1;
                break;
              }
          }
        if (!found)
          continue;
        int mindex = marks2d_inc->fetch (i).index2;
        Metric *orig_metric = orig_mlist->get_items ()->fetch (mindex);
        if (orig_metric->get_id () == mitem->get_id ()
            && mitem->get_subtype () == Metric::INCLUSIVE)
          {
            table0->append (index2);
            table1->append (1);
          }
      }

    for (int i = 0; i < marks2d->size (); i++)
      {
        int found = 0;
        for (int j = 0; j < sel_objs->size (); j++)
          {
            int sel_index = (int) sel_objs->fetch (j);
            int marked_index = marks2d->fetch (i).index1;
            if (sel_index == marked_index)
              {
                found = 1;
                break;
              }
          }
        if (!found)
          continue;
        int mindex = marks2d->fetch (i).index2;
        Metric *orig_metric = orig_mlist->get_items ()->fetch (mindex);
        if (orig_metric->get_id () == mitem->get_id ()
            && mitem->get_subtype () == Metric::EXCLUSIVE)
          {
            table0->append (index2);
            table1->append (0);
          }
      }
    if (!(mitem->get_subtype () == Metric::EXCLUSIVE
          || mitem->get_subtype () == Metric::DATASPACE))
      index2++;
  }
  table->store (0, table0);
  table->store (1, table1);
  return table;
}

// Get a vector of function ids of data(begin, begin + length - 1)
// Currently only support source/disassembly view
Vector<uint64_t>*
dbeGetFuncId (int dbevindex, int type, int begin, int length)
{
  Vector<uint64_t>* table = new Vector<uint64_t > ();
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();

  Hist_data *data;
  Function* given_func = NULL;
  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      data = dbev->dis_data;
      break;
    default:
      data = NULL;
      abort ();
    }

  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;

  if (begin < 0 || begin + length > data->size ())
    return NULL;

  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
    case DSP_DISASM:
    case DSP_DISASM_V2:
      {
        for (int i = begin; i < begin + length; i++)
          {
            given_func = NULL;
            Histable * sel_obj = data->fetch (i)->obj;
            if (sel_obj != NULL)
              given_func = (Function*) (sel_obj)->convertto (Histable::FUNCTION, (Histable*) dbev);
            if (given_func == NULL)
              table->append (0);
            else
              table->append (given_func->id);
          }
      }
      break;
    default:
      abort ();
    }
  return table;
}

Vector<void*>*
dbeGetFuncCallerInfo (int dbevindex, int type, Vector<int>* idxs, int groupId)
{
  Vector<void*>* data = new Vector<void*>();
  if (type == DSP_SOURCE_V2 || type == DSP_DISASM_V2)
    {
      Obj sel_func = dbeGetSelObj (dbevindex, DSP_FUNCTION, 0);
      if (sel_func == 0)
        return data;
      Vector<Obj> * cmpObjs = dbeGetComparableObjsV2 (dbevindex, sel_func, type);
      if (cmpObjs == NULL)
        return data;
      DbeView *dbev = dbeSession->getView (dbevindex);
      int mtype = MET_COMMON | COMPARE_BIT | ((groupId + 1) << GROUP_ID_SHIFT);
      MetricList *mlist = dbev->get_metric_list ((MetricType) (mtype & MTYPE_MASK),
                                                 (mtype & COMPARE_BIT) != 0,
                                                 mtype >> GROUP_ID_SHIFT);
      Histable *selObj = (Histable *) cmpObjs->fetch (groupId);
      int subtype = 0;
      Hist_data *hist_data = dbev->get_data (mlist, selObj, type, subtype);
      if (hist_data == NULL)
        return data;
    }
  for (int i = 0; i < idxs->size (); i++)
    data->append (dbeGetFuncCallerInfoById (dbevindex, type, idxs->fetch (i)));
  return data;
}

//
// Get Table of Caller info:
// param: idx -- selected AT_FUNC row
// return: callsite_id, callsite_name (function: file: line)
Vector<void*>*
dbeGetFuncCallerInfoById (int dbevindex, int type, int idx)
{
  Vector<void*>* table = new Vector<void*>(3);
  Vector<uint64_t>* table0 = new Vector<uint64_t> ();
  Vector<int>* table1 = new Vector<int> ();
  Vector<char*>* table2 = new Vector<char*>();

  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Hist_data *data;
  Function* given_func = NULL;
  Vector<Histable*> *instr_info = NULL;
  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      data = dbev->dis_data;
      break;
    default:
      data = NULL;
      abort ();
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;

  if (idx < 0 || idx >= data->size ())
    return NULL;
  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
    case DSP_DISASM:
    case DSP_DISASM_V2:
      {
        Histable * sel_obj = data->fetch (idx)->obj;
        if (sel_obj == NULL)
          return NULL;
        given_func = (Function*) (sel_obj)->convertto (Histable::FUNCTION, (Histable*) dbev);
        if (given_func == NULL)
          return NULL;
        PathTree * ptree = dbev->get_path_tree ();
        if (ptree == NULL)
          return NULL;
        instr_info = ptree->get_clr_instr (given_func);
        DefaultMap<uint64_t, int> * line_seen = new DefaultMap<uint64_t, int>();
        for (int j = 0; j < ((Vector<Histable*>*)instr_info)->size (); j++)
          {
            Histable *instr = ((Vector<Histable*>*)instr_info)->fetch (j);
            Function *cur_func = NULL;
            if (instr->get_type () == Histable::INSTR)
              cur_func = ((DbeInstr*) instr)->func;
            else if (instr->get_type () == Histable::LINE)
              cur_func = ((DbeLine*) instr)->func;
            if (cur_func == NULL || (cur_func->flags & FUNC_FLAG_SIMULATED))
                continue; // skip functions like <Total>
            Histable* line;
            switch (type)
              {
              case DSP_SOURCE:
              case DSP_SOURCE_V2:
                if (cur_func != NULL)
                  {
                    SourceFile *sourceFile = cur_func->getDefSrc ();
                    if (sourceFile == NULL ||
                        (sourceFile->flags & SOURCE_FLAG_UNKNOWN) != 0)
                      continue; // skip functions like <Function: %s, instructions without line numbers>
                  }
                line = instr->convertto (Histable::LINE, NULL);
                break;
              case DSP_DISASM:
              case DSP_DISASM_V2:
                line = instr->convertto (Histable::INSTR, NULL);
                break;
              default:
                abort ();
              }
            uint64_t func_id = cur_func->id;
            uint64_t line_id = instr->id;
            int is_null = 0;
            int line_no = -1;
            switch (type)
              {
              case DSP_SOURCE:
              case DSP_SOURCE_V2:
                is_null = (((DbeLine*) line)->func == NULL) ? 1 : 0;
                if (is_null)
                  ((DbeLine*) line)->func = cur_func;
                line_no = ((DbeLine*) line)->lineno;
                if (line_seen->get (line_id) == 0)
                  {
                    line_seen->put (line_id, 1);
                    table0->append (func_id);
                    table1->append (line_no);
                    Histable::NameFormat nfmt = dbev->get_name_format ();
                    table2->append (dbe_strdup (line->get_name (nfmt)));
                  }
                if (is_null)
                  ((DbeLine*) line)->func = NULL;
                break;
              case DSP_DISASM:
              case DSP_DISASM_V2:
                is_null = (((DbeInstr*) line)->func == NULL) ? 1 : 0;
                if (is_null)
                  ((DbeInstr*) line)->func = cur_func;
                line_no = ((DbeInstr*) line)->addr;
                if (line_seen->get (line_id) == 0)
                  {
                    line_seen->put (line_id, 1);
                    table0->append (func_id);
                    table1->append (line_no);
                    Histable::NameFormat nfmt = dbev->get_name_format ();
                    table2->append (dbe_strdup (line->get_name (nfmt)));
                  }
                if (is_null)
                  ((DbeInstr*) line)->func = NULL;
                break;
              default:
                abort ();
              }
         }
        delete line_seen;
        delete instr_info;
      }
      break;
    default:
      abort ();
    }
  table->store (0, table0);
  table->store (1, table1);
  table->store (2, table2);
  return table;
}

Vector<void*>*
dbeGetFuncCalleeInfo (int dbevindex, int type, Vector<int>* idxs, int groupId)
{
  Vector<void*>* data = new Vector<void*>();
  if (type == DSP_SOURCE_V2 || type == DSP_DISASM_V2)
    {
      Obj sel_func = dbeGetSelObj (dbevindex, DSP_FUNCTION, 0);
      if (sel_func == 0)
        return data;
      Vector<Obj> * cmpObjs = dbeGetComparableObjsV2 (dbevindex, sel_func, type);
      if (cmpObjs == NULL)
        return data;
      DbeView *dbev = dbeSession->getView (dbevindex);
      int mtype = MET_COMMON | COMPARE_BIT | ((groupId + 1) << GROUP_ID_SHIFT);
      MetricList *mlist = dbev->get_metric_list ((MetricType) (mtype & MTYPE_MASK),
                                                 (mtype & COMPARE_BIT) != 0,
                                                 mtype >> GROUP_ID_SHIFT);
      Histable *selObj = (Histable *) cmpObjs->fetch (groupId);
      int subtype = 0;
      Hist_data *hist_data = dbev->get_data (mlist, selObj, type, subtype);
      if (hist_data == NULL)
        return data;
    }

  for (int i = 0; i < idxs->size (); i++)
    data->append (dbeGetFuncCalleeInfoById (dbevindex, type, idxs->fetch (i)));
  return data;
}

//
// Get Table of Callee info:
// param: idx -- selected AT_FUNC row
// return: callsite_row, callee_id, callee_name
//
Vector<void*>*
dbeGetFuncCalleeInfoById (int dbevindex, int type, int idx)
{
  Vector<void*>* table = new Vector<void*>(3);
  Vector<int>* table0 = new Vector<int>();
  Vector<uint64_t>* table1 = new Vector<uint64_t > ();
  Vector<char*>* table2 = new Vector<char*>();
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Hist_data *data;
  Function* given_func = NULL;
  Vector<Histable*> *instr_info = NULL;
  Vector<void*> *func_info = NULL;

  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      data = dbev->dis_data;
      break;
    default:
      data = NULL;
      abort ();
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;
  if (idx < 0 || idx >= data->size ())
    return NULL;
  switch (type)
    {
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
    case DSP_DISASM:
    case DSP_DISASM_V2:
      {
        Histable * sel_obj = data->fetch (idx)->obj;
        if (sel_obj == NULL)
          return NULL;
        given_func = (Function*) (sel_obj)->convertto (Histable::FUNCTION, (Histable*) dbev);
        if (given_func == NULL)
          return NULL;
        PathTree * ptree = dbev->get_path_tree ();
        if (ptree == NULL)
          return NULL;
        Vector<Histable*> *instrs = NULL;
        Vector<void*> *callee_instrs = ptree->get_cle_instr (given_func, instrs);
        func_info = new Vector<void*>();
        instr_info = new Vector<Histable*>();
        for (long a = 0, sz_a = callee_instrs ? callee_instrs->size () : 0; a < sz_a; a++)
          {
            Vector<Histable*> *temp = ((Vector<Vector<Histable*>*>*)callee_instrs)->get (a);
            DefaultMap<Function*, int> * func_seen = new DefaultMap<Function*, int>();
            Histable* instr0 = (Histable*) instrs->fetch (a);
            for (long b = 0, sz_b = temp ? temp->size () : 0; b < sz_b; b++)
              {
                Histable *instr = temp->get (b);
                if (instr->get_type () == Histable::INSTR)
                  {
                    Function* func1 = ((DbeInstr *) instr)->func;
                    func_seen->put (func1, 1);
                  }
                else if (instr->get_type () == Histable::LINE)
                  {
                    Function* func1 = ((DbeLine *) instr)->func;
                    func_seen->put (func1, 1);
                  }
              }
            Vector<Function*> *funcs = func_seen->keySet ();
            delete func_seen;
            if (funcs->size () > 0)
              {
                instr_info->append (instr0);
                func_info->append (funcs);
              }
          }
        delete instrs;
        destroy (callee_instrs);

        DefaultMap<uint64_t, Vector<int>* > * instr_idxs = new DefaultMap<uint64_t, Vector<int>* >();
        DefaultMap<uint64_t, int> * func_idxs = new DefaultMap<uint64_t, int>();
        for (long j = 0, sz_j = instr_info ? instr_info->size () : 0; j < sz_j; j++)
          {
            Histable *instr = instr_info->get (j);
            Function *cur_func = NULL;
            if (instr->get_type () == Histable::INSTR)
              cur_func = ((DbeInstr*) instr)->func;
            else if (instr->get_type () == Histable::LINE)
              cur_func = ((DbeLine*) instr)->func;
            if (cur_func != NULL && (cur_func->flags & FUNC_FLAG_SIMULATED))
              continue; // skip functions like <Total>
            Histable* line;
            switch (type)
              {
              case DSP_SOURCE:
              case DSP_SOURCE_V2:
                if (cur_func != NULL)
                  {
                    SourceFile *sourceFile = cur_func->getDefSrc ();
                    if (sourceFile == NULL ||
                        (sourceFile->flags & SOURCE_FLAG_UNKNOWN) != 0)
                      // skip functions like <Function: %s, instructions without line numbers>
                      continue;
                  }
                line = instr->convertto (Histable::LINE, NULL);
                if (type == DSP_SOURCE_V2)
                  line = dbev->get_compare_obj (line);
                break;
              case DSP_DISASM:
              case DSP_DISASM_V2:
                line = instr;
                if (type == DSP_DISASM_V2)
                  line = dbev->get_compare_obj (line);
                break;
              default:
                abort ();
              }
            if (func_idxs->get (line->id) == 0)
              {
                func_idxs->put (line->id, 1);
                Vector<int> *temp_idx = new Vector<int>();
                temp_idx->append (j);
                instr_idxs->put (line->id, temp_idx);
              }
            else
              {
                Vector<int> *temp_idx = instr_idxs->get (line->id);
                temp_idx->append (j);
              }
          }
        for (long i = 0; i < data->size (); i++)
          {
            Histable* line = data->fetch (i)->obj;
            if (line == NULL)
              continue;
            Vector<int> * instr_idx = instr_idxs->get (line->id);
            if (instr_idx == NULL)
              continue;
            for (long j = 0; j < instr_idx->size (); j++)
              {
                Vector<void*>* callee_funcs_vec = (Vector<void*>*)func_info;
                if (callee_funcs_vec->size () == 0)
                  continue;
                Vector<Function*>* callee_funcs_value = (Vector<Function*>*)callee_funcs_vec->fetch (instr_idx->fetch (j));
                for (int k = 0; callee_funcs_value != NULL && k < callee_funcs_value->size (); k++)
                  {
                    uint64_t funcobj_id = ((Function*) callee_funcs_value->fetch (k))->id;
                    int old_size = table0->size ();
                    if (old_size > 0 && i == table0->fetch (old_size - 1)
                        && funcobj_id == table1->fetch (old_size - 1))
                      continue;
                    table0->append (i);
                    table1->append (funcobj_id);
                    table2->append (dbe_strdup (((Function*) callee_funcs_value->fetch (k))->get_name ()));
                  }
              }
          }
        delete instr_idxs;
        delete func_idxs;
        destroy (func_info);
        delete instr_info;
      }
      break;
    default:
      abort ();
    }
  table->store (0, table0);
  table->store (1, table1);
  table->store (2, table2);
  return table;
}

//
// Get Table of Function List data with only total values
//
Vector<void*> *
dbeGetFuncListMini (int dbevindex, int type, int /*subtype*/)
{
  Hist_data *data;
  DbeView *dbev = dbeSession->getView (dbevindex);
  switch (type)
    {
    case DSP_FUNCTION:
      data = dbev->func_data;
      break;
    default:
      data = NULL;
      break;
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;

  MetricList *mlist = data->get_metric_list ();

  // Get table size: count visible metrics
  int nvisible = 0;
  for (long i = 0, sz = mlist->size (); i < sz; i++)
    {
      Metric *m = mlist->get (i);
      if (m->is_visible () || m->is_tvisible () || m->is_pvisible ())
        nvisible++;
    }
  Vector<void*> *table = new Vector<void*>(nvisible + 1);

  // Fill function list elements
  Hist_data::HistItem *totals = data->get_totals ();
  for (long i = 0, sz = mlist->size (); i < sz; i++)
    {
      Metric *m = mlist->get (i);
      if (!m->is_visible () && !m->is_tvisible () && !m->is_pvisible ())
        continue;
      TValue res;
      TValue *v = data->get_value (&res, i, totals);
      if ((m->get_visbits () & VAL_RATIO) != 0)
        {
          Vector<double> *col = new Vector<double>(1);
          double d = (v->tag != VT_LABEL) ? v->to_double () : 100.; // NaN
          col->append (d);
          table->append (col);
          continue;
        }
      switch (m->get_vtype ())
        {
        case VT_INT:
          {
            Vector<int> *col = new Vector<int>(1);
            col->append (v->i);
            table->append (col);
            break;
          }
        case VT_ADDRESS:
        case VT_ULLONG:
        case VT_LLONG:
          {
            Vector<long long> *col = new Vector<long long>(1);
            col->append (v->ll);
            table->append (col);
            break;
          }
        case VT_LABEL:
          {
            Vector<char *> *col = new Vector<char *>(1);
            col->append (dbe_strdup (v->l));
            table->append (col);
            break;
          }
        case VT_DOUBLE:
        default:
          {
            Vector<double> *col = new Vector<double>(1);
            col->append (v->d);
            table->append (col);
            break;
          }
        }
    }
  table->append (NULL);
  return table;
}

// Get Table of Function List data
Vector<void*> *
dbeGetFuncList (int dbevindex, int type, int subtype)
{
  MetricList *mlist;
  Metric *mitem;
  int nitems, nvisible;
  int index, index2, nv;
  char *cell;
  Vector<int> *ji_list;
  Hist_data *data;
  Hist_data::HistItem *item;

  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();

  // fprintf(stderr, NTXT("XXX dbeGetFuncList, FuncListDisp_type = %d\n"), type);
  switch (type)
    {
    case DSP_FUNCTION:
      data = dbev->func_data;
      break;
    case DSP_LINE:
      data = dbev->line_data;
      break;
    case DSP_PC:
      data = dbev->pc_data;
      break;
    case DSP_SOURCE:
    case DSP_SOURCE_V2:
      data = dbev->src_data;
      break;
    case DSP_DISASM:
    case DSP_DISASM_V2:
      data = dbev->dis_data;
      break;
    case DSP_SELF:
      data = dbev->fitem_data;
      break;
    case DSP_CALLER:
      data = dbev->callers;
      break;
    case DSP_CALLEE:
      data = dbev->callees;
      break;
    case DSP_DLAYOUT:
      data = dbev->dlay_data;
      break;
    case DSP_DATAOBJ:
      data = dbev->dobj_data;
      break;
    case DSP_MEMOBJ:
    case DSP_INDXOBJ:
      data = dbev->get_indxobj_data (subtype);
      break;
    default:
      data = NULL;
      break;
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;
  mlist = data->get_metric_list ();

  // Get table size: count visible metrics
  nitems = data->size ();
  nvisible = 0;
  Vec_loop (Metric*, mlist->get_items (), index, mitem)
  {
    if (mitem->is_visible () || mitem->is_tvisible () || mitem->is_pvisible ())
      nvisible++;
  }

  // Initialize Java String array
  Vector<void*> *table = new Vector<void*>(nvisible + 1);

  // Mark Hi-value metric items for annotated src/dis/layout
  if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_DLAYOUT
      || type == DSP_SOURCE_V2 || type == DSP_DISASM_V2)
    {
      ji_list = new Vector<int>(nitems);

      if (dbev->marks->size () > 0)
        index = dbev->marks->fetch (0);
      else
        index = -1;
      int mindex = 0;
      for (index2 = 0; index2 < nitems; index2++)
        {
          item = data->fetch (index2);
          if (index2 == index)
            {
              ji_list->store (index2, -item->type);
              if (++mindex < dbev->marks->size ())
                index = dbev->marks->fetch (mindex);
              else
                index = -1;
            }
          else
            ji_list->store (index2, item->type);
        }
      table->store (nvisible, ji_list);
    }
  else
    table->store (nvisible, NULL);

  // Fill function list elements
  nv = 0;

  Vec_loop (Metric*, mlist->get_items (), index, mitem)
  {
    if (!mitem->is_visible () && !mitem->is_tvisible () &&
        !mitem->is_pvisible ())
      continue;

    // Fill values
    switch (mitem->get_vtype ())
      {
      case VT_LABEL:
        {
          Vector<char*> *jobjects = new Vector<char*>(nitems);
          char *buf = NULL;
          size_t bufsz = 0;
          int lspace = 0;
          if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_SOURCE_V2
              || type == DSP_DISASM_V2)
            {
              // if this is source or disassembly, where we'll insert
              //        a preface into the output line, figure out how wide
              //        it needs to be
              // first, scan all the lines, to get the maximum line number
              bufsz = 1024;
              buf = (char *) malloc (bufsz);
              int max_lineno = 0;
              int hidx;
              Hist_data::HistItem *hitem;
              Vec_loop (Hist_data::HistItem*, data, hidx, hitem)
              {
                if (!hitem->obj)
                  continue;
                if (hitem->obj->get_type () == Histable::LINE &&
                    ((DbeLine*) hitem->obj)->lineno > max_lineno)
                  max_lineno = ((DbeLine*) hitem->obj)->lineno;
                else if (hitem->obj->get_type () == Histable::INSTR
                         && ((DbeInstr*) hitem->obj)->lineno > max_lineno)
                  max_lineno = ((DbeInstr*) hitem->obj)->lineno;
              }

              // we have the maximum integer over all linenumbers in the file
              //        figure out how many digits are needed
              lspace = snprintf (buf, bufsz, NTXT ("%d"), max_lineno);
            }
          for (index2 = 0; index2 < nitems; index2++)
            {
              item = data->fetch (index2);
              if (type == DSP_DLAYOUT)
                cell = dbe_strdup (((DataObject*) (item->obj))->get_offset_name ());
              else if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_SOURCE_V2 || type == DSP_DISASM_V2)
                {
                  // This code is duplicated in output.cc, yet it's
                  // intended for presentation purpose and thus is
                  // potentially different for er_print and analyzer.
                  switch (item->type)
                    {
                    case Module::AT_SRC_ONLY:
                    case Module::AT_SRC:
                      if (item->obj == NULL)
                        snprintf (buf, bufsz, NTXT (" %*c. "), lspace, ' ');
                      else
                        snprintf (buf, bufsz, NTXT (" %*d. "), lspace, ((DbeLine*) item->obj)->lineno);
                      break;
                    case Module::AT_FUNC:
                    case Module::AT_QUOTE:
                      snprintf (buf, bufsz, NTXT ("%*c"), lspace + 3, ' ');
                      break;
                    case Module::AT_DIS:
                    case Module::AT_DIS_ONLY:
                      if (item->obj == NULL || ((DbeInstr*) item->obj)->lineno == -1)
                        snprintf (buf, bufsz, NTXT ("%*c[%*s] "), lspace + 3, ' ', lspace, NTXT ("?"));
                      else
                        snprintf (buf, bufsz, NTXT ("%*c[%*d] "), lspace + 3, ' ', lspace,
                                  ((DbeInstr*) item->obj)->lineno);
                      break;
                    case Module::AT_COM:
                    case Module::AT_EMPTY:
                      *buf = (char) 0;
                      break;
                    }
                  // get the line's text
                  char *s = item->value[index].l;
                  if (s != NULL)
                    {
                      // copy the string expanding all tabulations
                      // (JTable doesn't render them)
                      char *d = buf + strlen (buf);
                      char c;
                      size_t column = 0;
                      do
                        {
                          c = *s++;
                          if (c == '\t')
                            {
                              do
                                {
                                  *d++ = ' ';
                                  column++;
                                }
                              while (column & 07);
                            }
                          else
                            {
                              *d++ = c;
                              column++;
                            }
                          if (column + 32 > bufsz)
                            {
                              // Reallocate the buffer
                              size_t curlen = d - buf;
                              bufsz += 1024;
                              char *buf_new = (char *) malloc (bufsz);
                              strncpy (buf_new, buf, curlen);
                              buf_new[curlen] = '\0';
                              free (buf);
                              buf = buf_new;
                              d = buf + curlen;
                            }
                        }
                      while (c != (char) 0);
                    }
                  cell = dbe_strdup (buf);
                  free (item->value[index].l);
                  item->value[index].l = NULL; //YXXX missing from dbeGetFuncListV2
                }
              else
                {
                  // omazur: why don't we have it as metric value
                  Histable::NameFormat nfmt = dbev->get_name_format ();
                  cell = dbe_strdup (item->obj->get_name (nfmt));
                }
              jobjects->store (index2, cell);
            }
          if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_SOURCE_V2
              || type == DSP_DISASM_V2)
            free (buf);
          table->store (nv++, jobjects);
          break;
        }
      default:
        table->store (nv++, dbeGetTableDataOneColumn (data, index));
        break;
      }
  }
  return table;
}

Vector<Obj> *
dbeGetComparableObjsV2 (int /* dbevindex */, Obj sel_obj, int type)
{
  long grsize = dbeSession->expGroups->size ();
  Vector<Obj> *res = new Vector<Obj> (grsize + 1);
  for (long j = 0; j < grsize; j++)
    res->append ((Obj) NULL);
  res->append (sel_obj);
  Histable *obj = (Histable *) sel_obj;
  if (obj == NULL)
    return res;
  Function *func = (Function *) obj->convertto (Histable::FUNCTION);
  if (func == NULL)
    return res;
  Vector<Histable *> *cmpObjs = func->get_comparable_objs ();
  if (cmpObjs == NULL || cmpObjs->size () != grsize)
    return res;

  Histable::Type conv_type = (type == DSP_SOURCE || type == DSP_SOURCE_V2) ?
          Histable::LINE : Histable::INSTR;
  switch (obj->get_type ())
    {
    case Histable::FUNCTION:
      for (long j = 0; j < grsize; j++)
        res->store (j, (Obj) cmpObjs->get (j));
      return res;
    case Histable::INSTR:
    case Histable::LINE:
      {
        SourceFile *srcContext = (SourceFile *) obj->convertto (Histable::SOURCEFILE);
        char *bname = get_basename (srcContext->get_name ());
        for (long j = 0; j < grsize; j++)
          {
            Function *func1 = (Function *) cmpObjs->get (j);
            if (func == func1)
              {
                if (conv_type == Histable::LINE)
                  res->store (j, (Obj) obj);
                else
                  res->store (j, (Obj) obj->convertto (conv_type, srcContext));
                continue;
              }
            if (func1 == NULL)
              continue;
            Vector<SourceFile*> *sources = func1->get_sources ();
            SourceFile *sf = NULL;
            for (long j1 = 0, sz1 = sources ? sources->size () : 0; j1 < sz1; j1++)
              {
                SourceFile *sf1 = sources->get (j1);
                if (sf1 == srcContext)
                  { // the same file
                    sf = srcContext;
                    break;
                  }
                else if (sf == NULL)
                  {
                    char *bname1 = get_basename (sf1->get_name ());
                    if (dbe_strcmp (bname, bname1) == 0)
                      sf = sf1;
                  }
              }
            res->store (j, (Obj) func1->convertto (conv_type, srcContext));
          }
        break;
      }
    default:
      break;
    }
  return res;
}

// Get Table of Function List data
Vector<void *> *
dbeGetFuncListV2 (int dbevindex, int mtype, Obj sel_obj, int type, int subtype)
{
  Metric *mitem;
  int nitems, nvisible;
  int index, index2, nv;
  char *cell;
  Hist_data::HistItem *item;
  DbeView *dbev = dbeSession->getView (dbevindex);
  dbev->error_msg = dbev->warning_msg = NULL;
  MetricList *mlist = dbev->get_metric_list ((MetricType) (mtype & MTYPE_MASK),
                                             (mtype & COMPARE_BIT) != 0,
                                             mtype >> GROUP_ID_SHIFT);
  Histable *selObj = (Histable *) sel_obj;
  int old_compare_mode = dbev->get_compare_mode ();
  if ((mtype & COMPARE_BIT) != 0)
    dbev->reset_compare_mode (CMP_DISABLE);
  Hist_data *data = dbev->get_data (mlist, selObj, type, subtype);
  dbev->reset_compare_mode (old_compare_mode);
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;
  nitems = data->size ();
  nvisible = mlist->get_items ()->size ();

  // Initialize Java String array
  Vector<void*> *table = new Vector<void*>(nvisible + 3);
  // Mark Hi-value metric items for annotated src/dis/layout
  if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_DLAYOUT
      || type == DSP_SOURCE_V2 || type == DSP_DISASM_V2)
    {
      Vector<int> *types = new Vector<int>(nitems);
      Vector<Obj> *ids = new Vector<Obj > (nitems);
      if (dbev->marks->size () > 0)
        index = dbev->marks->fetch (0);
      else
        index = -1;
      int mindex = 0;
      for (int i = 0; i < nitems; i++)
        {
          item = data->fetch (i);
          ids->store (i, (Obj) item->obj);
          if (i == index)
            {
              types->store (i, -item->type);
              if (++mindex < dbev->marks->size ())
                index = dbev->marks->fetch (mindex);
              else
                index = -1;
            }
          else
            types->store (i, item->type);
        }
      table->store (nvisible, types);
      table->store (nvisible + 1, ids);
    }
  else
    {
      table->store (nvisible, NULL);
      table->store (nvisible + 1, NULL);
    }

  // Fill function list elements
  nv = 0;
  Vec_loop (Metric*, mlist->get_items (), index, mitem)
  {
    if (!mitem->is_visible () && !mitem->is_tvisible () &&
        !mitem->is_pvisible ())
      continue;

    // Fill values
    switch (mitem->get_vtype ())
      {
      default:
        table->store (nv++, dbeGetTableDataOneColumn (data, index));
        break;
      case VT_LABEL:
        Vector<char*> *jobjects = new Vector<char*>(nitems);
        char *buf = NULL;
        size_t bufsz = 0;
        int lspace = 0;
        if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_SOURCE_V2
            || type == DSP_DISASM_V2)
          {
            // if this is source or disassembly, where we'll insert
            //  a preface into the output line, figure out how wide
            //  it needs to be
            // first, scan all the lines, to get the maximum line number
            bufsz = 1024;
            buf = (char *) malloc (bufsz);
            int max_lineno = 0;
            int hidx;
            Hist_data::HistItem *hitem;
            Vec_loop (Hist_data::HistItem*, data, hidx, hitem)
            {
              if (!hitem->obj)
                continue;
              if (hitem->obj->get_type () == Histable::LINE &&
                  ((DbeLine*) hitem->obj)->lineno > max_lineno)
                max_lineno = ((DbeLine*) hitem->obj)->lineno;
              else if (hitem->obj->get_type () == Histable::INSTR
                       && ((DbeInstr*) hitem->obj)->lineno > max_lineno)
                max_lineno = ((DbeInstr*) hitem->obj)->lineno;
            }

            // we have the maximum integer over all linenumbers in the file
            //  figure out how many digits are needed
            lspace = snprintf (buf, bufsz, NTXT ("%d"), max_lineno);
          }

        for (index2 = 0; index2 < nitems; index2++)
          {
            item = data->fetch (index2);
            if (type == DSP_DLAYOUT)
              cell = dbe_strdup (((DataObject*) (item->obj))->get_offset_name ());
            else if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_SOURCE_V2 || type == DSP_DISASM_V2)
              {
                // This code is duplicated in output.cc, yet it's
                // intended for presentation purpose and thus is
                // potentially different for er_print and analyzer.
                switch (item->type)
                  {
                  case Module::AT_SRC_ONLY:
                  case Module::AT_SRC:
                    if (item->obj == NULL)
                      snprintf (buf, bufsz, NTXT (" %*c. "), lspace, ' ');
                    else
                      snprintf (buf, bufsz, NTXT (" %*d. "), lspace,
                                ((DbeLine*) item->obj)->lineno);
                    break;
                  case Module::AT_FUNC:
                  case Module::AT_QUOTE:
                    snprintf (buf, bufsz, NTXT ("%*c"), lspace + 3, ' ');
                    break;
                  case Module::AT_DIS:
                  case Module::AT_DIS_ONLY:
                    if (item->obj == NULL || ((DbeInstr*) item->obj)->lineno == -1)
                      snprintf (buf, bufsz, NTXT ("%*c[%*s] "), lspace + 3, ' ',
                                lspace, NTXT ("?"));
                    else
                      snprintf (buf, bufsz, NTXT ("%*c[%*d] "), lspace + 3, ' ',
                                lspace,
                                ((DbeInstr*) item->obj)->lineno);
                    break;
                  case Module::AT_COM:
                  case Module::AT_EMPTY:
                    *buf = (char) 0;
                    break;
                  }
                // get the line's text
                char *s = item->value[index].l;
                if (s != NULL)
                  {
                    // copy the string expanding all tabulations
                    // (JTable doesn't render them)
                    char *d = buf + strlen (buf);
                    char c;
                    size_t column = 0;
                    do
                      {
                        c = *s++;
                        if (c == '\t')
                          {
                            do
                              {
                                *d++ = ' ';
                                column++;
                              }
                            while (column & 07);
                          }
                        else
                          {
                            *d++ = c;
                            column++;
                          }
                        if (column + 32 > bufsz)
                          {
                            // Reallocate the buffer
                            size_t curlen = d - buf;
                            bufsz += 1024;
                            char *buf_new = (char *) malloc (bufsz);
                            strncpy (buf_new, buf, curlen);
                            buf_new[curlen] = '\0';
                            free (buf);
                            buf = buf_new;
                            d = buf + curlen;
                          }
                      }
                    while (c != (char) 0);
                  }
                cell = dbe_strdup (buf);
              }
            else
              {
                Histable::NameFormat nfmt = dbev->get_name_format ();
                cell = dbe_strdup (item->obj->get_name (nfmt));
              }
            jobjects->store (index2, cell);
          }

        if (type == DSP_SOURCE || type == DSP_DISASM || type == DSP_SOURCE_V2
            || type == DSP_DISASM_V2)
          free (buf);
        table->store (nv++, jobjects);
        break;
      }
  }
  table->append (dbeGetMetricList (mlist));
  return table;
} // dbeGetFuncListV2

//
// Get Table DataV2
//
Vector<void*> *
dbeGetTableDataV2 (int dbevindex, char *mlistStr, char *modeStr, char *typeStr,
                   char *subtypeStr, Vector<uint64_t> *ids)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();

  // Process metric list specification
  if (mlistStr == NULL)
    return NULL;
  bool met_call = false;
  MetricList *mlist = NULL;
  if (streq (mlistStr, NTXT ("MET_NORMAL")))
    mlist = dbev->get_metric_list (MET_NORMAL);
  else if (streq (mlistStr, NTXT ("MET_CALL")))
    {
      met_call = true;
      mlist = dbev->get_metric_list (MET_CALL);
    }
  else if (streq (mlistStr, NTXT ("MET_CALL_AGR")))
    mlist = dbev->get_metric_list (MET_CALL_AGR);
  else if (streq (mlistStr, NTXT ("MET_DATA")))
    mlist = dbev->get_metric_list (MET_DATA);
  else if (streq (mlistStr, NTXT ("MET_INDX")))
    mlist = dbev->get_metric_list (MET_INDX);
  else if (streq (mlistStr, NTXT ("MET_IO")))
    mlist = dbev->get_metric_list (MET_IO);
  else if (streq (mlistStr, NTXT ("MET_HEAP")))
    mlist = dbev->get_metric_list (MET_HEAP);
  else
    return NULL;

  // Process mode specification
  if (modeStr == NULL)
    return NULL;
  Hist_data::Mode mode = (Hist_data::Mode)0;
  if (streq (modeStr, NTXT ("CALLERS")))
    mode = Hist_data::CALLERS;
  else if (streq (modeStr, NTXT ("CALLEES")))
    mode = Hist_data::CALLEES;
  else if (streq (modeStr, NTXT ("SELF")))
    mode = Hist_data::SELF;
  else if (streq (modeStr, NTXT ("ALL")))
    mode = Hist_data::ALL;
  else
    return NULL;

  // Process type specification
  if (typeStr == NULL)
    return NULL;
  Histable::Type type = Histable::OTHER;
  if (streq (typeStr, NTXT ("FUNCTION")))
    type = Histable::FUNCTION;
  else if (streq (typeStr, NTXT ("INDEXOBJ")))
    type = Histable::INDEXOBJ;
  else if (streq (typeStr, NTXT ("IOACTFILE")))
    type = Histable::IOACTFILE;
  else if (streq (typeStr, NTXT ("IOACTVFD")))
    type = Histable::IOACTVFD;
  else if (streq (typeStr, NTXT ("IOCALLSTACK")))
    type = Histable::IOCALLSTACK;
  else if (streq (typeStr, NTXT ("HEAPCALLSTACK")))
    type = Histable::HEAPCALLSTACK;
  else if (streq (typeStr, NTXT ("LINE")))
    type = Histable::LINE;
  else if (streq (typeStr, NTXT ("INSTR")))
    type = Histable::INSTR;
  else
    // XXX Accepting objects other than above may require a different
    // implementation of the id -> Histable mapping below
    return NULL;

  // Process subtype specification
  int subtype = 0;
  if (subtypeStr != NULL)
    subtype = atoi (subtypeStr);
  Vector<Histable*> *hobjs = NULL;
  if (ids != NULL)
    {
      hobjs = new Vector<Histable*>();
      for (int i = 0; i < ids->size (); ++i)
        {
          Histable::Type obj_type = type;
          if ((obj_type == Histable::LINE || obj_type == Histable::INSTR)
              && subtype == 0)
            obj_type = Histable::FUNCTION;
          Histable *hobj = dbeSession->findObjectById (obj_type, subtype, ids->fetch (i));
          if ((obj_type == Histable::LINE || obj_type == Histable::INSTR)
              && subtype == 0 && hobj == NULL)
            return NULL;
          hobjs->append (hobj);
        }
    }

  PathTree::PtreeComputeOption flag = PathTree::COMPUTEOPT_NONE;
  if (dbev->isOmpDisMode () && type == Histable::FUNCTION
      && mode == Hist_data::CALLEES && met_call)
    flag = PathTree::COMPUTEOPT_OMP_CALLEE;

  Hist_data *data = dbev->get_hist_data (mlist, type, subtype, mode, hobjs, NULL, NULL, flag);
  return dbeGetTableDataV2Data (dbev, data);
}

static Vector<void*> *
dbeGetTableDataV2Data (DbeView * /*dbev*/, Hist_data *data)
{
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;
  MetricList *mlist;
  mlist = data->get_metric_list ();
  int nitems = data->size ();

  // Initialize Java String array
  Vector<void*> *table = new Vector<void*>(mlist->size () + 1);

  // Fill function list elements
  for (long i = 0, sz = mlist->size (); i < sz; i++)
    {
      Metric *mitem = mlist->get (i);
      if (!mitem->is_visible () && !mitem->is_tvisible () &&
          !mitem->is_pvisible ())
        continue;
      table->append (dbeGetTableDataOneColumn (data, i));
    }

  // Add an array of Histable IDs
  Vector<uint64_t> *idList = new Vector<uint64_t>(nitems);
  for (int i = 0; i < nitems; ++i)
    {
      Hist_data::HistItem *item = data->fetch (i);
      if (item->obj->get_type () == Histable::LINE
          || item->obj->get_type () == Histable::INSTR)
        idList->store (i, (uint64_t) (item->obj));
      else
        idList->store (i, item->obj->id);
    }
  table->append (idList);
  return table;
} // dbeGetTableData

//YXXX try to use the following to consolidate similar cut/paste code

static Vector<void*> *
dbeGetTableDataOneColumn (Hist_data *data, int met_ind)
{
  // Allocates a vector and fills it with metric values for one column
  TValue res;
  Metric *m = data->get_metric_list ()->get (met_ind);
  if ((m->get_visbits () & VAL_RATIO) != 0)
    {
      Vector<double> *col = new Vector<double>(data->size ());
      for (long row = 0, sz_row = data->size (); row < sz_row; row++)
        {
          TValue *v = data->get_value (&res, met_ind, row);
          double d = (v->tag != VT_LABEL) ? v->to_double () : 100.; // NaN
          col->append (d);
        }
      return (Vector<void*> *) col;
    }

  switch (m->get_vtype ())
    {
    case VT_DOUBLE:
      {
        Vector<double> *col = new Vector<double>(data->size ());
        for (long row = 0, sz_row = data->size (); row < sz_row; row++)
          {
            TValue *v = data->get_value (&res, met_ind, row);
            col->append (v->d);
          }
        return (Vector<void*> *) col;
      }
    case VT_INT:
      {
        Vector<int> *col = new Vector<int>(data->size ());
        for (long row = 0, sz_row = data->size (); row < sz_row; row++)
          {
            TValue *v = data->get_value (&res, met_ind, row);
            col->append (v->i);
          }
        return (Vector<void*> *) col;
      }
    case VT_ULLONG:
    case VT_LLONG:
      {
        Vector<long long> *col = new Vector<long long>(data->size ());
        for (long row = 0, sz_row = data->size (); row < sz_row; row++)
          {
            TValue *v = data->get_value (&res, met_ind, row);
            col->append (v->ll);
          }
        return (Vector<void*> *) col;
      }
    case VT_ADDRESS:
      {
        Vector<long long> *col = new Vector<long long>(data->size ());
        for (long row = 0, sz_row = data->size (); row < sz_row; row++)
          {
            TValue *v = data->get_value (&res, met_ind, row);
            // set the highest bit to mark this jlong as
            // a VT_ADDRESS (rather than a regular VT_LLONG)
            col->append (v->ll | 0x8000000000000000ULL);
          }
        return (Vector<void*> *) col;
      }
    case VT_LABEL:
      {
        Vector<char *> *col = new Vector<char *>(data->size ());
        for (long row = 0, sz_row = data->size (); row < sz_row; row++)
          {
            TValue *v = data->get_value (&res, met_ind, row);
            col->append (dbe_strdup (v->l));
          }
        return (Vector<void*> *) col;
      }
    default:
      return NULL;
    }
}

static Vector<void*> *
dbeGetTableDataOneColumn (DbeView *dbev, Vector<Hist_data::HistItem*> *data,
                          ValueTag vtype, int metricColumnNumber)
// Allocates a vector and fills it with metric values for one column
{
  Vector<void*> *column_data = NULL;
  int nitems = data->size (); // number of rows
  int index = metricColumnNumber;
  switch (vtype)
    {
    case VT_DOUBLE:
      {
        Vector<double> *jd_list = new Vector<double>(nitems);
        for (int index2 = 0; index2 < nitems; index2++)
          {
            Hist_data::HistItem *item = data->fetch (index2);
            jd_list->store (index2, item->value[index].d);
          }
        column_data = (Vector<void*> *)jd_list;
        break;
      }
    case VT_INT:
      {
        Vector<int> *ji_list = new Vector<int>(nitems);
        for (int index2 = 0; index2 < nitems; index2++)
          {
            Hist_data::HistItem *item = data->fetch (index2);
            ji_list->store (index2, item->value[index].i);
          }
        column_data = (Vector<void*> *)ji_list;
        break;
      }
    case VT_ULLONG:
    case VT_LLONG:
      {
        Vector<long long> *jl_list = new Vector<long long>(nitems);
        for (int index2 = 0; index2 < nitems; index2++)
          {
            Hist_data::HistItem *item = data->fetch (index2);
            jl_list->store (index2, item->value[index].ll);
          }
        column_data = (Vector<void*> *)jl_list;
        break;
      }
    case VT_ADDRESS:
      {
        Vector<long long> *jl_list = new Vector<long long>(nitems);
        for (int index2 = 0; index2 < nitems; index2++)
          {
            Hist_data::HistItem *item = data->fetch (index2);

            // set the highest bit to mark this jlong as
            // a VT_ADDRESS (rather than a regular VT_LLONG)
            uint64_t addr = item->value[index].ll;
            addr |= 0x8000000000000000ULL;
            jl_list->store (index2, addr);
          }
        column_data = (Vector<void*> *)jl_list;
        break;
      }
    case VT_LABEL:
      {
        Vector<char*> *jobjects = new Vector<char*>(nitems);
        for (int index2 = 0; index2 < nitems; index2++)
          {
            Hist_data::HistItem *item = data->fetch (index2);

            // omazur: why don't we have it as metric value
            Histable::NameFormat nfmt = dbev->get_name_format ();
            char *str = dbe_strdup (item->obj->get_name (nfmt));
            jobjects->store (index2, str);
          }
        column_data = (Vector<void*> *)jobjects;
        break;
      }
    default:
      abort ();
    }
  return column_data;
}

int
dbeGetCallTreeNumLevels (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  PathTree * ptree = dbev->get_path_tree ();
  if (ptree == NULL)
    return 0;
  return ptree->get_ftree_depth ();
}

Vector<void*>*
dbeGetCallTreeLevel (int dbevindex, char *mcmd, int level)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  PathTree * ptree = dbev->get_path_tree ();
  if (ptree == NULL)
    return NULL;
  if (mcmd == NULL)
    return NULL;
  BaseMetric *bm = dbeSession->find_base_reg_metric (mcmd);
  if (bm == NULL)
    return NULL;
  return ptree->get_ftree_level (bm, level);
}

Vector<void*>*
dbeGetCallTreeLevels (int dbevindex, char *mcmd)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  PathTree * ptree = dbev->get_path_tree ();
  if (ptree == NULL)
    return NULL;
  if (mcmd == NULL)
    return NULL;
  BaseMetric *bm = dbeSession->find_base_reg_metric (mcmd);
  if (bm == NULL)
    return NULL;

  int depth = ptree->get_ftree_depth ();
  Vector<void*> *results = new Vector<void*>(depth);
  for (int ii = 0; ii < depth; ii++)
    results->append (ptree->get_ftree_level (bm, ii));
  return results;
}

Vector<void*>*
dbeGetCallTreeLevelFuncs (int dbevindex, int start_level, int end_level)
{ // (0,-1) -> all levels
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  PathTree * ptree = dbev->get_path_tree ();
  if (ptree == NULL)
    return NULL;

  int depth = ptree->get_ftree_depth ();
  if (start_level < 0)
    start_level = 0;
  if (end_level < 0 || end_level >= depth)
    end_level = depth - 1;

  Histable::NameFormat nfmt = dbev->get_name_format (); //YXXX or fixed format?
  Vector<char*> *funcNames = new Vector<char*>();
  Vector<long long> *funcIds = new Vector<long long>();
  Vector<Obj> *funcObjs = new Vector<Obj>();

  if (start_level == 0 && end_level == depth - 1)
    return dbeGetCallTreeFuncs (dbevindex);
  else
    {
      for (int ii = start_level; ii <= end_level; ii++)
        {
          Vector<void*> *info = ptree->get_ftree_level (NULL, ii); /*no metric*/
          if (!info)
            continue;
          Vector<long long> *fids = (Vector<long long> *)info->get (2);
          if (!fids)
            continue;
          int index;
          long long fid;
          Vec_loop (long long, fids, index, fid)
          {
            funcIds->append (fid);
            Histable *obj = dbeSession->findObjectById (fid);
            char * fname = obj ? dbe_strdup (obj->get_name (nfmt)) : NULL;
            funcNames->append (fname);
            funcObjs->append ((unsigned long) obj); // avoiding sign extension
          }
          destroy (info);
        }
    }
  Vector<void*> *results = new Vector<void*>(3);
  results->append (funcIds);
  results->append (funcNames);
  results->append (funcObjs);
  return results;
}

Vector<void*> *
dbeGetCallTreeFuncs (int dbevindex)
{ // does not require ptree->get_ftree_level() to be computed
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  PathTree * ptree = dbev->get_path_tree ();
  if (ptree == NULL)
    return 0;
  Vector<Function*>* funcs = ptree->get_funcs (); // Unique functions in tree
  if (funcs == NULL)
    return NULL;

  long sz = funcs->size ();
  Vector<void*> *results = new Vector<void*>(3);
  Vector<long long> *funcIds = new Vector<long long>(sz);
  Vector<char*> *funcNames = new Vector<char*>(sz);
  Vector<Obj> *funcObjs = new Vector<Obj>(sz);

  int index;
  Function * func;
  Histable::NameFormat nfmt = dbev->get_name_format (); //YXXX or fixed format?
  Vec_loop (Function *, funcs, index, func)
  {
    funcIds->append (func->id); // do we need IDs?
    char *fname = dbe_strdup (func->get_name (nfmt));
    funcNames->append (fname);
    funcObjs->append ((unsigned long) func); // avoiding sign extension
  }
  results->put (0, funcIds);
  results->put (1, funcNames);
  results->put (2, funcObjs);
  destroy (funcs);
  return results;
}

Vector<void*>*
dbeGetCallTreeChildren (int dbevindex, char *mcmd, Vector<int /*NodeIdx*/>*node_idxs)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (node_idxs == NULL || node_idxs->size () == 0)
    return NULL;
  long sz = node_idxs->size ();
  PathTree * ptree = dbev->get_path_tree ();
  if (ptree == NULL)
    return NULL;
  if (mcmd == NULL)
    return NULL;
  BaseMetric *bm = dbeSession->find_base_reg_metric (mcmd);
  if (bm == NULL)
    return NULL;

  Vector<void*> *results = new Vector<void*>(sz);
  for (long ii = 0; ii < sz; ii++)
    {
      PathTree::NodeIdx nodeIdx = node_idxs->get (ii); // upcasted from int
      results->append (ptree->get_ftree_node_children (bm, nodeIdx));
    }
  return results;
}

Vector<int> *
dbeGetGroupIds (int /*dbevindex*/)
{
  Vector<ExpGroup*> *groups = dbeSession->expGroups;
  int sz = groups->size ();
  Vector<int> *grIds = new Vector<int>(sz);
  for (int i = 0; i < sz; i++)
    grIds->store (i, groups->fetch (i)->groupId);
  return grIds;
}

//
// Get label for name column
//
Vector<char*> *
dbeGetNames (int dbevindex, int type, Obj sel_obj)
{
  char *s0, *s1, *s2;
  bool need_strdup = true;
  switch (type)
    {
    case DSP_SOURCE_V2:
    case DSP_DISASM_V2:
    case DSP_SOURCE:
    case DSP_DISASM:
      {
        if (sel_obj)
          {
            Histable *selObj = (Histable*) sel_obj;
            Function *func = (Function *) selObj->convertto (Histable::FUNCTION);
            if (func)
              {
                char *names[3] = {NULL, NULL, NULL};
                set_file_names (func, names);
                s0 = names[0];
                s1 = names[1];
                s2 = names[2];
                need_strdup = false;
                break;
              }
          }
        DbeView *dbev = dbeSession->getView (dbevindex);
        char **names = type == DSP_SOURCE || type == DSP_SOURCE_V2 ? dbev->names_src : dbev->names_dis;
        s0 = names[0];
        s1 = names[1];
        s2 = names[2];
        break;
      }
    case DSP_LINE:
      s0 = GTXT ("Lines");
      s1 = GTXT ("Function, line # in \"sourcefile\"");
      s2 = NTXT ("");
      break;
    case DSP_PC:
      s0 = GTXT ("PCs");
      s1 = GTXT ("Function + offset");
      s2 = NTXT ("");
      break;
    case DSP_DLAYOUT:
      s0 = GTXT ("Name");
      s1 = GTXT ("* +offset .element");
      s2 = NTXT ("");
      break;
    default:
      s0 = GTXT ("Name");
      s1 = s2 = NTXT ("");
      break;
    }
  if (need_strdup)
    {
      s0 = dbe_strdup (s0);
      s1 = dbe_strdup (s1);
      s2 = dbe_strdup (s2);
    }
  Vector<char*> *table = new Vector<char*>(3);
  table->store (0, s0);
  table->store (1, s1);
  table->store (2, s2);
  return table;
}

//
// Get Total/Maximum element of Function List
//
Vector<void*> *
dbeGetTotalMax (int dbevindex, int type, int subtype)
{
  Hist_data *data;
  int index;
  Hist_data::HistItem *total_item, *maximum_item;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();

  switch (type)
    {
    case DSP_LINE:
      data = dbev->line_data;
      break;
    case DSP_PC:
      data = dbev->pc_data;
      break;
    case DSP_CALLER:
      data = dbev->callers;
      break;
    case DSP_SELF:
    case DSP_CALLEE:
      data = dbev->callees;
      break;
    case DSP_DLAYOUT:
      data = dbev->dlay_data;
      break;
    case DSP_DATAOBJ:
      data = dbev->dobj_data;
      break;
    case DSP_MEMOBJ:
      data = dbev->get_indxobj_data (subtype);
      break;
    case DSP_INDXOBJ:
      data = dbev->get_indxobj_data (subtype);
      break;
    case DSP_FUNCTION: // annotated src/dis use func total/max
    case DSP_SOURCE:
    case DSP_DISASM:
    case DSP_SOURCE_V2:
    case DSP_DISASM_V2:
      data = dbev->func_data;
      break;
    default:
      abort ();
    }
  if (data == NULL || data->get_status () != Hist_data::SUCCESS)
    return NULL;

  // Get list size
  // XXX -- the original list has all items, visible or not;
  // XXX -- the one from Hist_data has only visible items,
  // XXX --    and should be the only ones computed
  // XXX --    Analyzer got confused (yesterday), when we used the shorter list
  // XXX -- Why can we fetch total/max for metrics never
  // XXX --    computed without core dumping?
  MetricList *mlist2 = data->get_metric_list ();
  int size = mlist2->get_items ()->size ();

  // Initialize Java array
  Vector<void*> *total_max = new Vector<void*>(2);
  Vector<double> *total = new Vector<double>(size);
  Vector<double> *maximum = new Vector<double>(size);

  // Fill total/maximum element
  total_item = data->get_totals ();
  maximum_item = data->get_maximums ();

  for (index = 0; index < size; index++)
    {
      total->store (index, total_item->value[index].to_double ());
      maximum->store (index, maximum_item->value[index].to_double ());
    }
  total_max->store (0, total);
  total_max->store (1, maximum);
  return total_max;
}

//
// Get Table of Overview List
Vector<void*> *
dbeGetStatisOverviewList (int dbevindex)
{
  int size;
  Ovw_data **data;
  Ovw_data::Ovw_item labels, *totals;
  int nitems;
  int index, index2;

  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->error_msg = dbev->warning_msg = NULL;

  size = dbeSession->nexps ();
  totals = new Ovw_data::Ovw_item[size + 1];
  data = new Ovw_data*[size + 1];
  data[0] = new Ovw_data ();

  for (index = 1; index <= size; index++)
    {
      data[index] = dbev->get_ovw_data (index - 1);
      if (data[index] == NULL)
        {
          Ovw_data::reset_item (&totals[index]); // set contents to zeros
          continue;
        }
      data[0]->sum (data[index]);
      totals[index] = data[index]->get_totals (); //shallow copy!
    }
  totals[0] = data[0]->get_totals ();

  // Get table size
  labels = data[0]->get_labels ();
  nitems = labels.size + 4;

  // Initialize Java String array
  Vector<void*> *table = new Vector<void*>(size + 4);
  Vector<char*> *jobjects = new Vector<char*>(nitems);

  // Set the label
  jobjects->store (0, dbe_strdup (GTXT ("Start Time (sec.)")));
  jobjects->store (1, dbe_strdup (GTXT ("End Time (sec.)")));
  jobjects->store (2, dbe_strdup (GTXT ("Duration (sec.)")));
  jobjects->store (3, dbe_strdup (GTXT ("Total Thread Time (sec.)")));
  jobjects->store (4, dbe_strdup (GTXT ("Average number of Threads")));

  for (index2 = 5; index2 < nitems; index2++)
    jobjects->store (index2, dbe_strdup (labels.values[index2 - 4].l));
  table->store (0, jobjects);

  // Set the data
  for (index = 0; index <= size; index++)
    {
      Vector<double> *jd_list = new Vector<double>(nitems);
      jd_list->store (0, tstodouble (totals[index].start));
      jd_list->store (1, tstodouble (totals[index].end));
      jd_list->store (2, tstodouble (totals[index].duration));
      jd_list->store (3, tstodouble (totals[index].tlwp));
      jd_list->store (4, totals[index].nlwp);
      for (index2 = 5; index2 < nitems; index2++)
        jd_list->store (index2, tstodouble (totals[index].values[index2 - 4].t));
      table->store (index + 1, jd_list);
    }
  for (index = 0; index <= size; index++)
    delete data[index];
  delete[] data;
  delete[] totals;
  return table;
}

// Get Table of Statistics List
Vector<void*> *
dbeGetStatisList (int dbevindex)
{
  int size;
  Stats_data **data;
  int nitems;
  int index, index2;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  dbev->error_msg = dbev->warning_msg = NULL;
  if ((size = dbeSession->nexps ()) == 0)
    return NULL;

  // Get statistics data
  data = (Stats_data **) malloc ((size + 1) * sizeof (Stats_data *));
  data[0] = new Stats_data ();
  for (index = 1; index <= size; index++)
    {
      data[index] = dbev->get_stats_data (index - 1);
      if (data[index] == NULL)
        continue;
      data[0]->sum (data[index]);
    }

  // Get table size
  nitems = data[0]->size ();

  // Initialize Java String array
  Vector<void*> *table = new Vector<void*>(size + 2);
  Vector<char*> *jobjects = new Vector<char*>(nitems);

  // Set the label
  for (index2 = 0; index2 < nitems; index2++)
    jobjects->store (index2, dbe_strdup (data[0]->fetch (index2).label));
  table->store (0, jobjects);

  // Set the data
  for (index = 0; index <= size; index++)
    {
      Vector<double> *jd_list = new Vector<double>(nitems);
      for (index2 = 0; index2 < nitems; index2++)
        {
          double val = 0;
          if (data[index])
            val = data[index]->fetch (index2).value.to_double ();
          jd_list->store (index2, val);
        }
      table->store (index + 1, jd_list);
    }
  if (data)
    {
      for (index = 0; index <= size; index++)
        delete data[index];
      free (data);
    }
  return table;
}


//
// Set summary list
//
static void
setSummary (Vector<Histable*> *objs, Vector<int> *saligns,
            Vector<char> *mnemonic, Vector<char*> *jlabels, Vector<char*> *jvalues)
{
  char *sname = NULL, *oname = NULL, *lname = NULL, *alias = NULL,
          *mangle = NULL, *address = NULL, *size = NULL,
          *name_0 = NULL, *sname_0 = NULL, *oname_0 = NULL, *lname_0 = NULL,
          *alias_0 = NULL, *mangle_0 = NULL;
  Function *func, *last_func = NULL;
  int one_func = 1;

  // Get the source/object/load-object files & aliases
  long long ll_size = 0;
  for (long i = 0; i < objs->size (); i++)
    {
      Histable *current_obj = objs->fetch (i);
      Histable::Type htype = current_obj->get_type ();
      if (htype == Histable::LOADOBJECT)
        lname = ((LoadObject *) current_obj)->dbeFile->get_location_info ();
      else if ((func = (Function*) current_obj->convertto (Histable::FUNCTION)) != NULL)
        {
          if (one_func && last_func != NULL && last_func != func)
            one_func = 0;
          last_func = func;
          sname = NULL;
          DbeLine *dbeline = (DbeLine*) current_obj->convertto (Histable::LINE);
          if (dbeline)
            {
              SourceFile *sf;
              if (dbeline->lineno == 0 && dbeline->include != NULL)
                sf = dbeline->include;
              else if (dbeline->sourceFile != NULL)
                sf = dbeline->sourceFile;
              else
                sf = func->getDefSrc ();
              if (sf)
                sname = sf->dbeFile->get_location_info ();
            }
          char *func_name = func->get_name ();
          mangle = func->get_mangled_name ();
          if (mangle && streq (func_name, mangle))
            mangle = NULL;
          Module *module = func->module;
          if (module != NULL)
            {
              module->read_stabs ();
              if (sname == NULL || strlen (sname) == 0)
                {
                  SourceFile *sf = module->getMainSrc ();
                  sname = sf->dbeFile->get_location_info ();
                }
              DbeFile *df = module->dbeFile;
              if (df == NULL || (df->filetype & DbeFile::F_JAVACLASS) == 0)
                df = module->loadobject->dbeFile;
              lname = df->get_location_info ();
              oname = lname;
              if (module->dot_o_file)
                oname = module->dot_o_file->dbeFile->get_location_info ();
            }

          if (htype == Histable::INSTR && dbeSession->is_datamode_available ())
            alias = ((DbeInstr*) current_obj)->get_descriptor ();
        }

      char *name = current_obj->get_name ();
      if (i == 0)
        {
          name_0 = name;
          lname_0 = lname;
          sname_0 = sname;
          oname_0 = oname;
          mangle_0 = mangle;
          alias_0 = alias;
          if (objs->size () == 1)
            {
              uint64_t addr = current_obj->get_addr ();
              address = dbe_sprintf (NTXT ("%lld:0x%08llX"),
                                     (long long) ADDRESS_SEG (addr),
                                     (long long) ADDRESS_OFF (addr));
            }
        }
      else
        {
          if (name_0 != name)
            name_0 = NULL;
          if (lname_0 != lname)
            lname_0 = NULL;
          if (sname_0 != sname)
            sname_0 = NULL;
          if (oname_0 != oname)
            oname_0 = NULL;
          if (mangle_0 != mangle)
            mangle_0 = NULL;
          if (alias_0 != alias)
            alias_0 = NULL;
        }
      if (current_obj->get_size () == -1)
        {
          if (size == NULL)
            size = dbe_strdup (GTXT ("(Unknown)"));
        }
      else
        ll_size += current_obj->get_size ();
    }
  if (size == NULL)
    size = dbe_sprintf (NTXT ("%lld"), ll_size);
  if (name_0 == NULL)
    {
      if (objs->size () > 1)
        {
          char *func_name = last_func == NULL ? NULL :
                  (one_func == 0 ? NULL : last_func->get_name ());
          name_0 = dbe_sprintf (NTXT ("%s%s%s (%lld %s)"),
                                func_name == NULL ? "" : func_name,
                                func_name == NULL ? "" : ": ",
                                GTXT ("Multiple Selection"),
                                (long long) objs->size (),
                                GTXT ("objects"));
        }
    }
  else
    name_0 = dbe_strdup (name_0);

  // Set the name area
  saligns->store (0, TEXT_LEFT);
  mnemonic->store (0, 'N');
  jlabels->store (0, dbe_strdup (GTXT ("Name")));
  jvalues->store (0, name_0);

  saligns->store (1, TEXT_LEFT);
  mnemonic->store (1, 'P');
  jlabels->store (1, dbe_strdup (GTXT ("PC Address")));
  jvalues->store (1, address);

  saligns->store (2, TEXT_LEFT);
  mnemonic->store (2, 'z');
  jlabels->store (2, dbe_strdup (GTXT ("Size")));
  jvalues->store (2, size);

  saligns->store (3, TEXT_RIGHT);
  mnemonic->store (3, 'r');
  jlabels->store (3, dbe_strdup (GTXT ("Source File")));
  jvalues->store (3, dbe_strdup (sname_0));

  saligns->store (4, TEXT_RIGHT);
  mnemonic->store (4, 'b');
  jlabels->store (4, dbe_strdup (GTXT ("Object File")));
  jvalues->store (4, dbe_strdup (oname_0));

  saligns->store (5, TEXT_LEFT);
  mnemonic->store (5, 'j');
  jlabels->store (5, dbe_strdup (GTXT ("Load Object")));
  jvalues->store (5, dbe_strdup (lname_0));

  saligns->store (6, TEXT_LEFT);
  mnemonic->store (6, 'm');
  jlabels->store (6, dbe_strdup (GTXT ("Mangled Name")));
  jvalues->store (6, dbe_strdup (mangle_0));

  saligns->store (7, TEXT_LEFT);
  mnemonic->store (7, 'A');
  jlabels->store (7, dbe_strdup (GTXT ("Aliases")));
  jvalues->store (7, dbe_strdup (alias_0));
}

// Set memory-object summary list
//
static void
setMemSummary (Vector<Histable*> *objs, Vector<int> *saligns,
               Vector<char> *mnemonic, Vector<char*> *jlabels,
               Vector<char*> *jvalues)
{
  saligns->store (0, TEXT_LEFT);
  mnemonic->store (0, 'M');
  jlabels->store (0, dbe_strdup (GTXT ("Memory Object")));
  if (objs->size () == 1)
    {
      Histable *current_obj = objs->fetch (0);
      jvalues->store (0, dbe_strdup (current_obj->get_name ()));
    }
  else
    {
      char *name = dbe_sprintf (NTXT ("%s (%lld %s)"),
                                GTXT ("Multiple Selection"),
                                (long long) objs->size (), GTXT ("objects"));
      jvalues->store (0, name);
    }
}

// Set index-object summary list
//
static void
setIndxSummary (Vector<Histable*> *objs, Vector<int> *saligns,
                Vector<char> *mnemonic, Vector<char*> *jlabels,
                Vector<char*> *jvalues)
{
  saligns->store (0, TEXT_LEFT);
  mnemonic->store (0, 'I');
  jlabels->store (0, dbe_strdup (GTXT ("Index Object")));

  if (objs->size () == 1)
    {
      Histable *current_obj = objs->fetch (0);
      jvalues->store (0, dbe_strdup (current_obj->get_name ()));
    }
  else
    {
      char *name = dbe_sprintf (NTXT ("%s (%lld %s)"), GTXT ("Multiple Selection"),
                                (long long) objs->size (), GTXT ("objects"));
      jvalues->store (0, name);
    }
}

// Set I/O activity summary list
//
static void
setIOActivitySummary (Vector<Histable*> *objs, Vector<int> *saligns,
                      Vector<char> *mnemonic, Vector<char*> *jlabels,
                      Vector<char*> *jvalues)
{
  saligns->store (0, TEXT_LEFT);
  mnemonic->store (0, 'O');
  jlabels->store (0, dbe_strdup (GTXT ("I/O Activity")));
  if (objs->size () == 1)
    {
      Histable *current_obj = objs->fetch (0);
      jvalues->store (0, dbe_strdup (current_obj->get_name ()));
    }
  else
    {
      char *name = dbe_sprintf (NTXT ("%s (%lld %s)"), GTXT ("Multiple Selection"),
                                (long long) objs->size (), GTXT ("objects"));
      jvalues->store (0, name);
    }
}

// Set heap activity summary list
//
static void
setHeapActivitySummary (Vector<Histable*> *objs, Vector<int> *saligns,
                        Vector<char> *mnemonic, Vector<char*> *jlabels,
                        Vector<char*> *jvalues)
{
  saligns->store (0, TEXT_LEFT);
  mnemonic->store (0, 'O');
  jlabels->store (0, dbe_strdup (GTXT ("Heap Activity")));

  if (objs->size () == 1)
    {
      Histable *current_obj = objs->fetch (0);
      jvalues->store (0, dbe_strdup (current_obj->get_name ()));
    }
  else
    {
      char *name = dbe_sprintf (NTXT ("%s (%lld %s)"), GTXT ("Multiple Selection"),
                                (long long) objs->size (), GTXT ("objects"));
      jvalues->store (0, name);
    }
}

//
// Set data-object summary list
//
static void
setDataSummary (Vector<Histable*> *objs, Vector<int> *saligns,
                Vector<char> *mnemonic, Vector<char*> *jlabels,
                Vector<char*> *jvalues)
{
  char *name, *type, *member, *elist;
  DataObject *dobj;
  Vector<DataObject *> *delem;
  Histable *scope;
  int index;
  char *size, *offset, *elements, *scopename;

  // Get the data object elements
  member = elist = type = size = offset = elements = scopename = NULL;

  if (objs->size () == 1)
    {
      Histable *current_obj = objs->fetch (0);
      name = dbe_strdup (current_obj->get_name ());
      dobj = (DataObject *) current_obj;
      type = dobj->get_typename ();
      scope = dobj->get_scope ();
      delem = dbeSession->get_dobj_elements (dobj);
      if (type == NULL)
        type = GTXT ("(Synthetic)");
      if (!scope)
        scopename = dbe_strdup (GTXT ("(Global)"));
      else
        {
          switch (scope->get_type ())
            {
            case Histable::FUNCTION:
              scopename = dbe_sprintf (NTXT ("%s(%s)"),
                                       ((Function*) scope)->module->get_name (),
                                       scope->get_name ());
              break;
            case Histable::LOADOBJECT:
            case Histable::MODULE:
            default:
              scopename = dbe_strdup (scope->get_name ());
              break;
            }
        }

      if (dobj->get_offset () != -1)
        {
          if (dobj->get_parent ())
            member = dbe_strdup (dobj->get_parent ()->get_name ());
          offset = dbe_sprintf (NTXT ("%lld"), (long long) dobj->get_offset ());
        }
      size = dbe_sprintf ("%lld", (long long) dobj->get_size ());

      if (delem->size () > 0)
        {
          elements = dbe_sprintf (NTXT ("%lld"), (long long) delem->size ());
          StringBuilder sb_tmp, sb;
          sb.append (GTXT ("Offset Size  Name\n"));
          for (index = 0; index < delem->size (); index++)
            {
              DataObject *ditem = delem->fetch (index);
              sb_tmp.sprintf (NTXT ("%6lld %5lld  %s\n"),
                              (long long) ditem->get_offset (),
                              (long long) ditem->get_size (), ditem->get_name ());
              sb.append (&sb_tmp);
            }
          if (sb.charAt (sb.length () - 1) == '\n')
            sb.setLength (sb.length () - 1);
          elist = sb.toString ();
        }
    }
  else
    name = dbe_sprintf (NTXT ("%s (%lld %s)"), GTXT ("Multiple Selection"),
                        (long long) objs->size (), GTXT ("objects"));

  saligns->store (0, TEXT_LEFT);
  mnemonic->store (0, 'D');
  jlabels->store (0, dbe_strdup (GTXT ("Data Object")));
  jvalues->store (0, name);

  saligns->store (1, TEXT_LEFT);
  mnemonic->store (1, 'S');
  jlabels->store (1, dbe_strdup (GTXT ("Scope")));
  jvalues->store (1, scopename);

  saligns->store (2, TEXT_LEFT);
  mnemonic->store (2, 'T');
  jlabels->store (2, dbe_strdup (GTXT ("Type")));
  jvalues->store (2, dbe_strdup (type));

  saligns->store (3, TEXT_LEFT);
  mnemonic->store (3, 'M');
  jlabels->store (3, dbe_strdup (GTXT ("Member of")));
  jvalues->store (3, member);

  saligns->store (4, TEXT_LEFT);
  mnemonic->store (4, 'O');
  jlabels->store (4, dbe_strdup (GTXT ("Offset")));
  jvalues->store (4, offset);

  saligns->store (5, TEXT_LEFT);
  mnemonic->store (5, 'z');
  jlabels->store (5, dbe_strdup (GTXT ("Size")));
  jvalues->store (5, size);

  saligns->store (6, TEXT_LEFT);
  mnemonic->store (6, 'E');
  jlabels->store (6, dbe_strdup (GTXT ("Elements")));
  jvalues->store (6, elements);

  saligns->store (7, TEXT_LEFT);
  mnemonic->store (7, 'L');
  jlabels->store (7, dbe_strdup (GTXT ("List")));
  jvalues->store (7, elist);
}

#define SUMMARY_NAME 8
#define DSUMMARY_NAME 8
#define LSUMMARY_NAME   7
#define IMSUMMARY_NAME   1

Vector<void*> *
dbeGetSummaryV2 (int dbevindex, Vector<Obj> *sel_objs, int type, int subtype)
{
  if (sel_objs == NULL || sel_objs->size () == 0)
    return NULL;
  DbeView *dbev = dbeSession->getView (dbevindex);
  Vector<Histable*>*objs = new Vector<Histable*>(sel_objs->size ());
  for (int i = 0; i < sel_objs->size (); i++)
    {
      Histable *obj = (Histable *) sel_objs->fetch (i);
      if (obj == NULL)
        continue;
      char *nm = obj->get_name ();
      if (streq (nm, NTXT ("<Total>")))
        {
          // Special case for 'Total'.
          // Multi selection which includes 'Total' is only 'Total'
          objs->reset ();
          objs->append (obj);
          break;
        }
      objs->append (obj);
    }
  if (objs->size () == 0)
    return NULL;

  // Set name area
  int nname = SUMMARY_NAME;
  Vector<int> *saligns = new Vector<int>(nname);
  Vector<char>*mnemonic = new Vector<char>(nname);
  Vector<char*> *jlabels = new Vector<char*>(nname);
  Vector<char*> *jvalues = new Vector<char*>(nname);
  Vector<void*> *name_objs = new Vector<void*>(4);
  name_objs->store (0, saligns);
  name_objs->store (1, mnemonic);
  name_objs->store (2, jlabels);
  name_objs->store (3, jvalues);
  setSummary (objs, saligns, mnemonic, jlabels, jvalues);

  MetricList *prop_mlist = new MetricList (dbev->get_metric_ref (MET_NORMAL));
  if (prop_mlist && dbev->comparingExperiments ())
    prop_mlist = dbev->get_compare_mlist (prop_mlist, 0);

  int nitems = prop_mlist->get_items ()->size ();

  // Set the metrics area
  jlabels = new Vector<char*>(nitems);
  Vector<double> *clock_list = new Vector<double>(nitems);
  Vector<double> *excl_list = new Vector<double>(nitems);
  Vector<double> *ep_list = new Vector<double>(nitems);
  Vector<double> *incl_list = new Vector<double>(nitems);
  Vector<double> *ip_list = new Vector<double>(nitems);
  Vector<int> *vtype = new Vector<int>(nitems);

  // Initialize Java String array
  Vector<void*> *metric_objs = new Vector<void*>(8);
  metric_objs->store (0, jlabels);
  metric_objs->store (1, clock_list);
  metric_objs->store (2, excl_list);
  metric_objs->store (3, ep_list);
  metric_objs->store (4, incl_list);
  metric_objs->store (5, ip_list);
  metric_objs->store (6, vtype);

  int last_init = -1;
  for (int i = 0; i < objs->size (); i++)
    {
      Histable *obj = objs->fetch (i);
      // Get the data to be displayed
      Hist_data *data = dbev->get_hist_data (prop_mlist, obj->get_type (), subtype,
                                             Hist_data::SELF, obj, dbev->sel_binctx, objs);

      if (data->get_status () != Hist_data::SUCCESS)
        {
          if (type != DSP_DLAYOUT)
            { // For data_layout, rows with zero metrics are OK
              delete data;
              continue;
            }
        }
      TValue *values = NULL;
      if (data->get_status () == Hist_data::SUCCESS)
        {
          Hist_data::HistItem *hi = data->fetch (0);
          if (hi)
            values = hi->value;
        }
      Hist_data::HistItem *total = data->get_totals ();
      int index2 = 0;
      char *tstr = GTXT (" Time");
      char *estr = GTXT ("Exclusive ");
      size_t len = strlen (estr);

      // get the metric list from the data
      MetricList *mlist = data->get_metric_list ();
      int index;
      Metric *mitem;
      double clock;
      Vec_loop (Metric*, mlist->get_items (), index, mitem)
      {
        if (mitem->get_subtype () == Metric::STATIC)
          continue;
        if (last_init < index2)
          {
            last_init = index2;
            jlabels->store (index2, NULL);
            clock_list->store (index2, 0.0);
            excl_list->store (index2, 0.0);
            ep_list->store (index2, 0.0);
            incl_list->store (index2, 0.0);
            ip_list->store (index2, 0.0);
            vtype->store (index2, 0);
          }
        double dvalue = (values != NULL) ? values[index].to_double () : 0.0;
        double dtotal = total->value[index].to_double ();
        if (mitem->is_time_val ())
          clock = 1.e+6 * dbeSession->get_clock (-1);
        else
          clock = 0.0;

        clock_list->store (index2, clock);
        if ((mitem->get_subtype () == Metric::EXCLUSIVE) ||
            (mitem->get_subtype () == Metric::DATASPACE))
          {
            if (i == 0)
              {
                char *sstr = mitem->get_name ();
                if (!strncmp (sstr, estr, len))
                  sstr += len;
                char *buf, *lstr = strstr (sstr, tstr);
                if (lstr)
                  buf = dbe_strndup (sstr, lstr - sstr);
                else
                  buf = dbe_strdup (sstr);
                jlabels->store (index2, buf);
                vtype->store (index2, mitem->get_vtype ());
              }
            dvalue += excl_list->fetch (index2);
            double percent = dtotal == 0.0 ? dtotal : (dvalue / dtotal) * 100;
            excl_list->store (index2, dvalue);
            ep_list->store (index2, percent);
          }
        else
          {
            dvalue += incl_list->fetch (index2);
            if (dvalue > dtotal)
              dvalue = dtotal; // temporary correction
            double percent = dtotal == 0.0 ? dtotal : (dvalue / dtotal) * 100;
            incl_list->store (index2, dvalue);
            ip_list->store (index2, percent);
            index2++;
          }
      }
      delete data;
    }
  delete prop_mlist;
  Vector<void*> *summary = new Vector<void*>(2);
  summary->store (0, name_objs);
  summary->store (1, metric_objs);
  return summary;
}

// Get Summary List
Vector<void*> *
dbeGetSummary (int dbevindex, Vector<Obj> *sel_objs, int type, int subtype)
{
  bool is_data, is_mem, is_indx, is_iodata, is_heapdata;
  Hist_data::HistItem *total;
  MetricList *prop_mlist; // as passed to get_hist_data
  MetricList *mlist; // as stored in the data
  Metric *mitem;
  int i, nname, nitems, index, index2;
  TValue *values;
  double dvalue, clock;
  Hist_data *data;
  Vector<double> *percent_scale;

  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (sel_objs == NULL || sel_objs->size () == 0)
    return NULL;

  is_mem = false;
  is_data = false;
  is_indx = false;
  is_iodata = false;
  is_heapdata = false;
  nname = SUMMARY_NAME;
  Vector<Histable*>*objs = new Vector<Histable*>(sel_objs->size ());
  if (type == DSP_TIMELINE)
    objs->append ((Histable *) sel_objs->fetch (0));
  else
    {
      switch (type)
        {
        case DSP_FUNCTION:
          data = dbev->func_data;
          break;
        case DSP_LINE:
          data = dbev->line_data;
          break;
        case DSP_PC:
          data = dbev->pc_data;
          break;
        case DSP_SELF:
          data = dbev->fitem_data;
          break;
        case DSP_SOURCE:
        case DSP_SOURCE_V2:
          data = dbev->src_data;
          break;
        case DSP_DISASM:
        case DSP_DISASM_V2:
          data = dbev->dis_data;
          break;
        case DSP_DLAYOUT:
          is_data = true;
          nname = LSUMMARY_NAME;
          data = dbev->dlay_data;
          break;
        case DSP_DATAOBJ:
          is_data = true;
          nname = DSUMMARY_NAME;
          data = dbev->dobj_data;
          break;
        case DSP_MEMOBJ:
          is_data = true;
          is_mem = true;
          nname = IMSUMMARY_NAME;
          data = dbev->get_indxobj_data (subtype);
          break;
        case DSP_INDXOBJ:
          is_indx = true;
          nname = IMSUMMARY_NAME;
          data = dbev->get_indxobj_data (subtype);
          break;
        case DSP_IOACTIVITY:
          is_iodata = true;
          nname = IMSUMMARY_NAME;
          data = dbev->iofile_data;
          break;
        case DSP_IOVFD:
          is_iodata = true;
          nname = IMSUMMARY_NAME;
          data = dbev->iovfd_data;
          break;
        case DSP_IOCALLSTACK:
          is_iodata = true;
          nname = IMSUMMARY_NAME;
          data = dbev->iocs_data;
          break;
        case DSP_HEAPCALLSTACK:
          is_heapdata = true;
          nname = IMSUMMARY_NAME;
          data = dbev->heapcs_data;
          break;
        default:
          data = NULL;
          break;
        }
      if (data == NULL || data->get_status () != Hist_data::SUCCESS)
        return NULL;

      Hist_data::HistItem *current_item;
      for (i = 0; i < sel_objs->size (); i++)
        {
          int sel_index = (int) sel_objs->fetch (i);
          if (type != DSP_IOACTIVITY && type != DSP_IOVFD &&
              type != DSP_IOCALLSTACK && type != DSP_HEAPCALLSTACK)
            {
              if (sel_index < 0 || sel_index >= data->size ())
                continue;
              current_item = data->fetch (sel_index);
              if (current_item->obj == NULL)
                continue;
            }
          else
            {
              if (sel_index < 0)
                continue;
              bool found = false;
              for (int j = 0; j < data->size (); j++)
                {
                  current_item = data->fetch (j);
                  if ((current_item->obj != NULL) && (current_item->obj->id == sel_index))
                    {
                      found = true;
                      break;
                    }
                }
              if (!found)
                continue;
            }
          char *nm = current_item->obj->get_name ();
          if (streq (nm, NTXT ("<Total>")))
            {
              // Special case for 'Total'.
              // Multi selection which includes 'Total' is only 'Total'
              objs->reset ();
              objs->append (current_item->obj);
              break;
            }
          objs->append (current_item->obj);
        }
    }
  if (objs->size () == 0)
    return NULL;

  // Set name area
  Vector<int> *saligns = new Vector<int>(nname);
  Vector<char>*mnemonic = new Vector<char>(nname);
  Vector<char*> *jlabels = new Vector<char*>(nname);
  Vector<char*> *jvalues = new Vector<char*>(nname);
  Vector<void*> *name_objs = new Vector<void*>(4);
  name_objs->store (0, saligns);
  name_objs->store (1, mnemonic);
  name_objs->store (2, jlabels);
  name_objs->store (3, jvalues);
  if (is_mem)
    setMemSummary (objs, saligns, mnemonic, jlabels, jvalues);
  else if (is_indx)
    setIndxSummary (objs, saligns, mnemonic, jlabels, jvalues);
  else if (is_data)
    setDataSummary (objs, saligns, mnemonic, jlabels, jvalues);
  else if (is_iodata)
    setIOActivitySummary (objs, saligns, mnemonic, jlabels, jvalues);
  else if (is_heapdata)
    setHeapActivitySummary (objs, saligns, mnemonic, jlabels, jvalues);
  else
    setSummary (objs, saligns, mnemonic, jlabels, jvalues);

  // Get the reference metrics
  if (is_data)
    prop_mlist = new MetricList (dbev->get_metric_ref (MET_DATA));
  else if (is_indx)
    prop_mlist = new MetricList (dbev->get_metric_ref (MET_INDX));
  else if (is_iodata)
    prop_mlist = new MetricList (dbev->get_metric_ref (MET_IO));
  else if (is_heapdata)
    prop_mlist = new MetricList (dbev->get_metric_ref (MET_HEAP));
  else
    prop_mlist = new MetricList (dbev->get_metric_ref (MET_NORMAL));

  // XXXX a workaround to avoid aggregated data for compare mode, only show base experiment data
  if (prop_mlist && dbev->comparingExperiments ())
    prop_mlist = dbev->get_compare_mlist (prop_mlist, 0);
  nitems = prop_mlist->get_items ()->size ();

  // Set the metrics area
  jlabels = new Vector<char*>(nitems);
  Vector<double> *clock_list = new Vector<double>(nitems);
  Vector<double> *excl_list = new Vector<double>(nitems);
  Vector<double> *ep_list = new Vector<double>(nitems);
  Vector<double> *incl_list = new Vector<double>(nitems);
  Vector<double> *ip_list = new Vector<double>(nitems);
  Vector<int> *vtype = new Vector<int>(nitems);

  // Initialize Java String array
  Vector<void*> *metric_objs = new Vector<void*>(8);
  metric_objs->store (0, jlabels);
  metric_objs->store (1, clock_list);
  metric_objs->store (2, excl_list);
  metric_objs->store (3, ep_list);
  metric_objs->store (4, incl_list);
  metric_objs->store (5, ip_list);
  metric_objs->store (6, vtype);
  percent_scale = new Vector<double>();
  int last_init = -1;
  for (i = 0; i < objs->size (); i++)
    {
      Histable *current_obj = objs->fetch (i);
      // Get the data to be displayed
      data = dbev->get_hist_data (prop_mlist, current_obj->get_type (), subtype,
                                  Hist_data::SELF, current_obj, dbev->sel_binctx, objs);
      if (data->get_status () != Hist_data::SUCCESS)
        {
          if (type != DSP_DLAYOUT)
            { // For data_layout, rows with zero metrics are OK
              delete data;
              continue;
            }
        }
      Hist_data::HistItem *hi = data->fetch (0);
      values = hi ? hi->value : NULL;
      total = data->get_totals ();
      index2 = 0;

      // get the metric list from the data
      mlist = data->get_metric_list ();

      // We loop over the metrics in mlist.
      // We construct index2, which tells us
      // the corresponding entry in the metric_objs lists.
      // We need this mapping multiple times.
      // So, if you change the looping in any way here,
      // do so as well in other similar loops.
      // All such loops are marked so:
      // See discussion on "mlist-to-index2 mapping".

      Vec_loop (Metric*, mlist->get_items (), index, mitem)
      {
        if (mitem->get_subtype () == Metric::STATIC)
          continue;
        if (last_init < index2)
          {
            last_init = index2;
            jlabels->store (index2, NULL);
            clock_list->store (index2, 0.0);
            excl_list->store (index2, 0.0);
            ep_list->store (index2, 0.0);
            incl_list->store (index2, 0.0);
            ip_list->store (index2, 0.0);
            vtype->store (index2, 0);
          }
        dvalue = (values != NULL) ? values[index].to_double () : 0.0;
        double dtotal = total->value[index].to_double ();
        percent_scale->store (index, dtotal == 0. ? 0. : 100. / dtotal);
        if (mitem->is_time_val ())
          clock = 1.e+6 * dbeSession->get_clock (-1);
        else
          clock = 0.0;

        clock_list->store (index2, clock);
        if (mitem->get_subtype () == Metric::EXCLUSIVE ||
            mitem->get_subtype () == Metric::DATASPACE)
          {
            if (i == 0)
              {
                char *sstr = mitem->get_username ();
                char *buf = dbe_strdup (sstr);
                jlabels->store (index2, buf);
                vtype->store (index2, mitem->get_vtype ());
              }
            dvalue += excl_list->fetch (index2);
            double percent = dvalue * percent_scale->fetch (index);
            excl_list->store (index2, dvalue);
            ep_list->store (index2, percent);
            if (is_data || is_indx || is_iodata || is_heapdata)
              // move to next row, except if there's inclusive data, too
              index2++;
          }
        else
          {
            dvalue += incl_list->fetch (index2);
            if (dvalue > dtotal && mitem->get_type () != BaseMetric::DERIVED)
              dvalue = dtotal; // temporary correction
            double percent = dvalue * percent_scale->fetch (index);
            incl_list->store (index2, dvalue);
            ip_list->store (index2, percent);
            index2++;
          }
      }
      delete data;
    }

  // for multi-selection, we have to recompute the derived metrics
  if (objs->size () > 1 &&
      dbev->get_derived_metrics () != NULL &&
      dbev->get_derived_metrics ()->get_items () != NULL &&
      dbev->get_derived_metrics ()->get_items ()->size () > 0)
    {
      // See discussion on "mlist-to-index2 mapping".
      Vector<Metric*> *mvec = new Vector<Metric*>(nitems);
      index2 = 0;
      Vec_loop (Metric*, prop_mlist->get_items (), index, mitem)
      {
        if (mitem->get_subtype () == Metric::STATIC)
          continue;
        if (mitem->get_subtype () == Metric::EXCLUSIVE ||
            mitem->get_subtype () == Metric::DATASPACE)
          {
            mvec->store (index2, mitem);
            if (is_data || is_indx || is_iodata || is_heapdata)
              index2++;
          }
        else
          {
            assert (strcmp (mvec->fetch (index2)->get_cmd (), mitem->get_cmd ()) == 0);
            index2++;
          }
      }
      int *map = dbev->get_derived_metrics ()->construct_map (mvec, BaseMetric::EXCLUSIVE, mvec->fetch (0)->get_expr_spec ());
      if (map != NULL)
        {
          int nmetrics = mvec->size ();
          double *evalues = (double *) malloc (nmetrics * sizeof (double));
          double *ivalues = (double *) malloc (nmetrics * sizeof (double));
          for (index2 = 0; index2 < nmetrics; index2++)
            {
              evalues[index2] = excl_list->fetch (index2);
              ivalues[index2] = incl_list->fetch (index2);
            }

          // evaluate derived metrics
          dbev->get_derived_metrics ()->eval (map, evalues);
          dbev->get_derived_metrics ()->eval (map, ivalues);
          for (index2 = 0; index2 < nmetrics; index2++)
            {
              excl_list->store (index2, evalues[index2]);
              incl_list->store (index2, ivalues[index2]);
            }

          // recompute percentages for derived metrics    EUGENE maybe all percentage computations should be moved here
          // See discussion on "mlist-to-index2 mapping".
          index2 = 0;
          Vec_loop (Metric*, prop_mlist->get_items (), index, mitem)
          {
            if (mitem->get_subtype () == Metric::STATIC)
              continue;
            if (mitem->get_subtype () == Metric::EXCLUSIVE ||
                mitem->get_subtype () == Metric::DATASPACE)
              {
                if (mitem->get_type () == BaseMetric::DERIVED)
                  ep_list->store (index2, excl_list->fetch (index2) * percent_scale->fetch (index));
                if (is_data || is_indx || is_iodata || is_heapdata)
                  index2++;
              }
            else
              {
                if (mitem->get_type () == BaseMetric::DERIVED)
                  ip_list->store (index2, incl_list->fetch (index2) * percent_scale->fetch (index));
                index2++;
              }
          }
          free (evalues);
          free (ivalues);
          free (map);
        }
      delete mvec;
    }
  delete prop_mlist;
  Vector<void*> *summary = new Vector<void*>(2);
  summary->store (0, name_objs);
  summary->store (1, metric_objs);
  delete objs;
  delete percent_scale;
  return summary;
}

char *
dbeGetExpName (int /*dbevindex*/, char *dir_name)
{
  char *ret;
  char *warn;
  if (col_ctr == NULL)
    col_ctr = new Coll_Ctrl (1); // Potential race condition?
  if (dir_name != NULL)
    {
      ret = col_ctr->set_directory (dir_name, &warn);
      // note that the warning and error msgs are written to stderr, not returned to caller
      if (warn != NULL)
        fprintf (stderr, NTXT ("%s"), warn);
      if (ret != NULL)
        fprintf (stderr, NTXT ("%s"), ret);
    }
  return dbe_strdup (col_ctr->get_expt ());
}

// === CollectDialog HWC info ===

Vector<Vector<char*>*> *
dbeGetHwcSets (int /*dbevindex*/, bool forKernel)
{
  Vector<Vector<char*>*> *list = new Vector<Vector<char*>*>(2);
  char * defctrs = hwc_get_default_cntrs2 (forKernel, 1);
  Vector<char*> *i18n = new Vector<char*>(1); // User name
  Vector<char*> *name = new Vector<char*>(1); // Internal name
  if (NULL != defctrs)
    {
      i18n->store (0, strdup (defctrs));
      name->store (0, strdup (NTXT ("default")));
    }
  list->store (0, i18n);
  list->store (1, name);
  return list;
}

static Vector<void*> *
dbeGetHwcs (Hwcentry **hwcs)
{
  int sz;
  for (sz = 0; hwcs && hwcs[sz]; sz++)
    ;
  Vector<void*> *list = new Vector<void*>(9);
  Vector<char*> *i18n = new Vector<char*>(sz);
  Vector<char*> *name = new Vector<char*>(sz);
  Vector<char*> *int_name = new Vector<char*>(sz);
  Vector<char*> *metric = new Vector<char*>(sz);
  Vector<long long> *val = new Vector<long long>(sz);
  Vector<int> *timecvt = new Vector<int>(sz);
  Vector<int> *memop = new Vector<int>(sz);
  Vector<char*> *short_desc = new Vector<char*>(sz);
  Vector<Vector<int>*> *reglist_v = new Vector<Vector<int>*>(sz);
  Vector<bool> *supportsAttrs = new Vector<bool>(sz);
  Vector<bool> *supportsMemspace = new Vector<bool>(sz);

  for (int i = 0; i < sz; i++)
    {
      Hwcentry *ctr = hwcs[i];
      Vector<int> *registers = new Vector<int>(MAX_PICS);
      regno_t *reglist = ctr->reg_list;
      for (int k = 0; !REG_LIST_EOL (reglist[k]) && k < MAX_PICS; k++)
        registers->store (k, reglist[k]);

      i18n->store (i, dbe_strdup (hwc_i18n_metric (ctr)));
      name->store (i, dbe_strdup (ctr->name));
      int_name->store (i, dbe_strdup (ctr->int_name));
      metric->store (i, dbe_strdup (ctr->metric));
      val->store (i, ctr->val); // signed promotion from int
      timecvt->store (i, ctr->timecvt);
      memop->store (i, ctr->memop);
      reglist_v->store (i, registers);
      short_desc->store (i, dbe_strdup (ctr->short_desc));
      supportsAttrs->store (i, true);
      supportsMemspace->store (i, ABST_MEMSPACE_ENABLED (ctr->memop));
    }
  list->store (0, i18n);
  list->store (1, name);
  list->store (2, int_name);
  list->store (3, metric);
  list->store (4, val);
  list->store (5, timecvt);
  list->store (6, memop);
  list->store (7, short_desc);
  list->store (8, reglist_v);
  list->store (9, supportsAttrs);
  list->store (10, supportsMemspace);
  return list;
}

Vector<void *> *
dbeGetHwcsAll (int /*dbevindex*/, bool forKernel)
{
  Vector<void*> *list = new Vector<void*>(2);
  list->store (0, dbeGetHwcs (hwc_get_std_ctrs (forKernel)));
  list->store (1, dbeGetHwcs (hwc_get_raw_ctrs (forKernel)));
  return list;
}

Vector<char*> *
dbeGetHwcHelp (int /*dbevindex*/, bool forKernel)
{
  Vector<char*> *strings = new Vector<char*>(32);
  FILE *f = tmpfile ();
  hwc_usage_f (forKernel, f, "", 0, 0, 1); // writes to f
  fflush (f);
  fseek (f, 0, SEEK_SET);
#define MAX_LINE_LEN 2048
  char buff[MAX_LINE_LEN];
  int ii = 0;
  while (fgets (buff, MAX_LINE_LEN, f))
    strings->store (ii++, dbe_strdup (buff));
  fclose (f);
  return strings;
}

Vector<char*> *
dbeGetHwcAttrList (int /*dbevindex*/, bool forKernel)
{
  char ** attr_list = hwc_get_attrs (forKernel); // Get Attribute list
  int size;
  for (size = 0; attr_list && attr_list[size]; size++)
    ;

  Vector<char*> *name = new Vector<char*>(size);
  for (int i = 0; i < size; i++)
    name->store (i, dbe_strdup (attr_list[i]));
  return name;
}

//Get maximum number of simultaneous counters
int
dbeGetHwcMaxConcurrent (int /*dbevindex*/, bool forKernel)
{
  return hwc_get_max_concurrent (forKernel);
}

// === End CollectDialog HWC info ===


//  Instruction-frequency data
Vector<char*> *
dbeGetIfreqData (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (!dbeSession->is_ifreq_available ())
    return NULL;
  int size = dbeSession->nexps ();
  if (size == 0)
    return NULL;

  // Initialize Java String array
  Vector<char*> *list = new Vector<char*>();
  for (int i = 0; i < size; i++)
    {
      Experiment *exp = dbeSession->get_exp (i);
      if (exp->broken || !dbev->get_exp_enable (i) || !exp->ifreqavail)
        continue;
      // write a header for the experiment
      list->append (dbe_sprintf (GTXT ("Instruction frequency data from experiment %s\n\n"),
                                 exp->get_expt_name ()));
      // add its instruction frequency messages
      char *ifreq = pr_mesgs (exp->fetch_ifreq (), NTXT (""), NTXT (""));
      list->append (ifreq);
    }
  return list;
}

//   LeakList related methods
//
Vector<void*> *
dbeGetLeakListInfo (int dbevindex, bool leakflag)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  MetricList *origmlist = dbev->get_metric_list (MET_NORMAL);
  MetricList *nmlist = new MetricList (origmlist);
  if (leakflag)
    nmlist->set_metrics (NTXT ("e.heapleakbytes:e.heapleakcnt:name"), true,
                         dbev->get_derived_metrics ());
  else
    nmlist->set_metrics (NTXT ("e.heapallocbytes:e.heapalloccnt:name"), true,
                         dbev->get_derived_metrics ());
  MetricList *mlist = new MetricList (nmlist);
  delete nmlist;

  CStack_data *lam = dbev->get_cstack_data (mlist);
  if (lam == NULL || lam->size () == 0)
    {
      delete lam;
      delete mlist;
      return NULL;
    }
  Vector<Vector<Obj>*> *evalue = new Vector<Vector<Obj>*>(lam->size ());
  Vector<Vector<Obj>*> *pcstack = new Vector<Vector<Obj>*>(lam->size ());
  Vector<Vector<Obj>*> *offstack = new Vector<Vector<Obj>*>(lam->size ());
  Vector<Vector<Obj>*> *fpcstack = new Vector<Vector<Obj>*>(lam->size ());
  Vector<Vector<Obj>*> *sumval = new Vector<Vector<Obj>*>(lam->size ());

  int index;
  CStack_data::CStack_item *lae;
  Vec_loop (CStack_data::CStack_item*, lam->cstack_items, index, lae)
  {
    Vector<Obj> *jivals = NULL;
    if (lae != NULL)
      {
        jivals = new Vector<Obj>(4);
        jivals->store (0, (Obj) (index + 1));
        jivals->store (1, (Obj) lae->value[1].ll);
        jivals->store (2, (Obj) lae->value[0].ll);
        jivals->store (3, (Obj) (leakflag ? 1 : 2));
      }
    evalue->store (index, jivals);
    int snum = lae->stack->size ();
    Vector<Obj> *jivals1 = new Vector<Obj>(snum);
    Vector<Obj> *jivals2 = new Vector<Obj>(snum);
    Vector<Obj> *jivals3 = new Vector<Obj>(snum);
    if (lae->stack != NULL)
      {
        for (int i = lae->stack->size () - 1; i >= 0; i--)
          {
            DbeInstr *instr = lae->stack->fetch (i);
            jivals1->store (i, (Obj) instr);
            jivals2->store (i, (Obj) instr->func);
            jivals3->store (i, (Obj) instr->addr);
          }
      }
    fpcstack->store (index, jivals1);
    pcstack->store (index, jivals2);
    offstack->store (index, jivals3);
    lae++;
  }
  Vector<Obj> *jivals4 = new Vector<Obj>(3);
  jivals4->store (0, (Obj) lam->size ());
  jivals4->store (1, (Obj) lam->total->value[1].ll);
  jivals4->store (2, (Obj) lam->total->value[0].ll);
  sumval->store (0, jivals4);
  delete lam;
  delete mlist;
  Vector<void*> *earray = new Vector<void*>(5);
  earray->store (0, evalue);
  earray->store (1, pcstack);
  earray->store (2, offstack);
  earray->store (3, fpcstack);
  earray->store (4, sumval);
  return earray;
}

// Map timeline address to function instr
//
Obj
dbeGetObject (int dbevindex, Obj sel_func, Obj sel_pc)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
   abort ();
  if (sel_pc)
    return sel_pc;
  return sel_func;
}

char *
dbeGetName (int /*dbevindex*/, int exp_id)
// This function's name is not descriptive enough - it returns a string
//   containing the full experiment name with path, process name, and PID.
// There are various dbe functions that provide experiment name and experiment
// details, and they should probably be consolidated/refactored. (TBR)
// For another example of similar output formatting, see dbeGetExpName().
{
  int id = (exp_id < 0) ? 0 : exp_id;
  Experiment *exp = dbeSession->get_exp (id);
  if (exp == NULL)
    return NULL;
  char *buf =
          dbe_sprintf (NTXT ("%s [%s, PID %d]"),
                       exp->get_expt_name (),
                       exp->utargname != NULL ? exp->utargname : GTXT ("(unknown)"),
                       exp->getPID ());
  return buf;
}

Vector<char*> *
dbeGetExpVerboseName (Vector<int> *exp_ids)
{
  int len = exp_ids->size ();
  Vector<char*> *list = new Vector<char*>(len);
  for (int i = 0; i < len; i++)
    {
      char * verboseName = dbeGetName (0, exp_ids->fetch (i)); // no strdup()
      list->store (i, verboseName);
    }
  return list;
}

long long
dbeGetStartTime (int /*dbevindex*/, int exp_id)
{
  int id = (exp_id < 0) ? 0 : exp_id;
  Experiment *exp = dbeSession->get_exp (id);
  return exp ? exp->getStartTime () : (long long) 0;
}

long long
dbeGetRelativeStartTime (int /*dbevindex*/, int exp_id)
{
  int id = (exp_id < 0) ? 0 : exp_id;
  Experiment *exp = dbeSession->get_exp (id);
  return exp ? exp->getRelativeStartTime () : (long long) 0;
}

long long
dbeGetEndTime (int /*dbevindex*/, int exp_id)
{
  int id = (exp_id < 0) ? 0 : exp_id;
  Experiment *exp = dbeSession->get_exp (id);

  // Experiment::getEndTime was initially implemented as
  // returning exp->last_event. To preserve the semantics
  // new Experiment::getLastEvent() is used here.
  return exp ? exp->getLastEvent () : (long long) 0;
}

int
dbeGetClock (int /*dbevindex*/, int exp_id)
{
  return dbeSession->get_clock (exp_id);
}

long long
dbeGetWallStartSec (int /*dbevindex*/, int exp_id)
{
  int id = (exp_id < 0) ? 0 : exp_id;
  Experiment *exp = dbeSession->get_exp (id);
  return exp ? exp->getWallStartSec () : 0ll;
}

char *
dbeGetHostname (int /*dbevindex*/, int exp_id)
{
  int id = (exp_id < 0) ? 0 : exp_id;
  Experiment *exp = dbeSession->get_exp (id);
  return exp ? dbe_strdup (exp->hostname) : NULL;
}

static DataView *
getTimelinePackets (int dbevindex, int exp_id, int data_id, int entity_prop_id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  const int sortprop_count = 3;
  const int sortprops[sortprop_count] = {
    PROP_HWCTAG, // aux
    entity_prop_id,
    PROP_TSTAMP
  };
  DataView *packets = dbev->get_filtered_events (exp_id, data_id,
                                                 sortprops, sortprop_count);
  return packets;
}

static long
getIdxByVals (DataView * packets, int aux, int entity_prop_val,
              uint64_t time, DataView::Relation rel)
{
  const int sortprop_count = 3;
  Datum tval[sortprop_count];
  tval[0].setUINT32 (aux);
  tval[1].setUINT32 (entity_prop_val); //CPUID, LWPID, THRID are downsized to 32
  tval[2].setUINT64 (time);
  long idx = packets->getIdxByVals (tval, rel);
  return idx;
}

static bool
isValidIdx (DataView * packets, int entity_prop_id,
            int aux, int entity_prop_val, long idx)
{
  if (idx < 0 || idx >= packets->getSize ())
    return false;
  int pkt_aux = packets->getIntValue (PROP_HWCTAG, idx);
  if (pkt_aux != aux)
    return false;
  if (entity_prop_id == PROP_EXPID)
    return true; // not a packet property; we know the packet is in this experiment
  if (entity_prop_id == PROP_NONE)
    return true; // not a packet property; we know the packet is in this experiment
  int pkt_ent = packets->getIntValue (entity_prop_id, idx);
  if (pkt_ent != entity_prop_val)
    return false;
  return true;
}

static bool
hasInvisbleTLEvents (Experiment *exp, VMode view_mode)
{
  if (exp->has_java && view_mode == VMODE_USER)
    return true;
  return false;
}

static bool
isVisibleTLEvent (Experiment *exp, VMode view_mode, DataView* packets, long idx)
{
  if (hasInvisbleTLEvents (exp, view_mode))
    {
      JThread *jthread = (JThread*) packets->getObjValue (PROP_JTHREAD, idx);
      if (jthread == JTHREAD_NONE || (jthread != NULL && jthread->is_system ()))
        return false;
    }
  return true;
}

static long
getTLVisibleIdxByStepping (Experiment *exp, VMode view_mode, int entity_prop_id,
                           DataView * packets, int aux, int entity_prop_val,
                           long idx, long move_count, int direction)
{
  assert (move_count >= 0);
  assert (direction == 1 || direction == -1 || direction == 0);
  if (direction == 0 /* precise hit required */)
    move_count = 0;
  do
    {
      if (!isValidIdx (packets, entity_prop_id, aux, entity_prop_val, idx))
        return -1;
      if (isVisibleTLEvent (exp, view_mode, packets, idx))
        {
          if (move_count <= 0)
            break;
          move_count--;
        }
      if (direction == 0)
        return -1;
      idx += direction;
    }
  while (1);
  return idx;
}

static long
getTLVisibleIdxByVals (Experiment *exp, VMode view_mode, int entity_prop_id,
                       DataView * packets,
                       int aux, int entity_prop_val, uint64_t time, DataView::Relation rel)
{
  long idx = getIdxByVals (packets, aux, entity_prop_val, time, rel);
  if (!hasInvisbleTLEvents (exp, view_mode))
    return idx;
  if (idx < 0)
    return idx;
  if (rel == DataView::REL_EQ)
    return -1; // would require bi-directional search... not supported for now
  int direction = (rel == DataView::REL_LT || rel == DataView::REL_LTEQ) ? -1 : 1;
  idx = getTLVisibleIdxByStepping (exp, view_mode, entity_prop_id, packets,
                                   aux, entity_prop_val,
                                   idx, 0 /* first match */, direction);
  return idx;
}

// In thread mode, the entity name for non Java thread should be the 1st func
// from the current thread's stack. See #4961315
static char*
getThreadRootFuncName (int, int, int, int, VMode)
{
  return NULL; // until we figure out what we want to show... YXXX
}

Vector<void*> *
dbeGetEntityProps (int dbevindex) //YXXX TBD, should this be exp-specific?
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Vector<int> *prop_id = new Vector<int>();
  Vector<char*> *prop_name = new Vector<char*>();
  Vector<char*> *prop_uname = new Vector<char*>();
  Vector<char*> *prop_cname = new Vector<char*>(); //must match TLModeCmd vals!

  prop_id->append (PROP_NONE);
  prop_name->append (dbe_strdup (GTXT ("NONE")));
  prop_uname->append (dbe_strdup (GTXT ("Unknown")));
  prop_cname->append (dbe_strdup (NTXT ("unknown")));

  prop_id->append (PROP_LWPID);
  prop_name->append (dbe_strdup (GTXT ("LWPID")));
  prop_uname->append (dbe_strdup (GTXT ("LWP")));
  prop_cname->append (dbe_strdup (NTXT ("lwp")));

  prop_id->append (PROP_THRID);
  prop_name->append (dbe_strdup (GTXT ("THRID")));
  prop_uname->append (dbe_strdup (GTXT ("Thread")));
  prop_cname->append (dbe_strdup (NTXT ("thread")));

  prop_id->append (PROP_CPUID);
  prop_name->append (dbe_strdup (GTXT ("CPUID")));
  prop_uname->append (dbe_strdup (GTXT ("CPU")));
  prop_cname->append (dbe_strdup (NTXT ("cpu")));

  prop_id->append (PROP_EXPID);
  prop_name->append (dbe_strdup (GTXT ("EXPID")));
  prop_uname->append (dbe_strdup (GTXT ("Process"))); // placeholder...
  // ...until we finalize how to expose user-level Experiments, descendents
  prop_cname->append (dbe_strdup (NTXT ("experiment")));
  Vector<void*> *darray = new Vector<void*>();
  darray->store (0, prop_id);
  darray->store (1, prop_name);
  darray->store (2, prop_uname);
  darray->store (3, prop_cname);
  return darray;
}

Vector<void*> *
dbeGetEntities (int dbevindex, int exp_id, int entity_prop_id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Experiment *exp = dbeSession->get_exp (exp_id);
  if (exp == NULL)
    return NULL;

  // Recognize and skip faketime experiments
  if (exp->timelineavail == false)
    return NULL;
  Vector<Histable*> *tagObjs = exp->getTagObjs ((Prop_type) entity_prop_id);
  int total_nelem;
  if (tagObjs)
    total_nelem = (int) tagObjs->size ();
  else
    total_nelem = 0;
  const VMode view_mode = dbev->get_view_mode ();
  bool show_java_threadnames = (entity_prop_id == PROP_THRID &&
                                view_mode != VMODE_MACHINE);
  // allocate the structures for the return
  Vector<int> *entity_prop_vals = new Vector<int>();
  Vector<char*> *jthr_names = new Vector<char*>();
  Vector<char*> *jthr_g_names = new Vector<char*>();
  Vector<char*> *jthr_p_names = new Vector<char*>();

  // now walk the tagObjs from the experiment, and check for filtering
  for (int tagObjsIdx = 0; tagObjsIdx < total_nelem; tagObjsIdx++)
    {
      int entity_prop_val = (int) ((Other *) tagObjs->fetch (tagObjsIdx))->tag;
      entity_prop_vals->append (entity_prop_val);
      char *jname, *jgname, *jpname;
      JThread *jthread = NULL;
      bool has_java_threadnames = false;
      if (show_java_threadnames)
        {
          jthread = exp->get_jthread (entity_prop_val);
          has_java_threadnames = (jthread != JTHREAD_DEFAULT
                                  && jthread != JTHREAD_NONE);
        }
      if (!has_java_threadnames)
        {
          jname = jgname = jpname = NULL;
          if (entity_prop_id == PROP_THRID || entity_prop_id == PROP_LWPID)
            // if non Java thread, set thread name to the 1st func
            // from the current thread's stack. see #4961315
            jname = getThreadRootFuncName (dbevindex, exp_id, entity_prop_id,
                                           entity_prop_val, view_mode);
        }
      else
        {
          jname = dbe_strdup (jthread->name);
          jgname = dbe_strdup (jthread->group_name);
          jpname = dbe_strdup (jthread->parent_name);
        }
      jthr_names->append (jname);
      jthr_g_names->append (jgname);
      jthr_p_names->append (jpname);
    }
  Vector<char*> *entity_prop_name_v = new Vector<char*>();
  char* entity_prop_name = dbeSession->getPropName (entity_prop_id);
  entity_prop_name_v->append (entity_prop_name);
  Vector<void*> *darray = new Vector<void*>(5);
  darray->store (0, entity_prop_vals);
  darray->store (1, jthr_names);
  darray->store (2, jthr_g_names);
  darray->store (3, jthr_p_names);
  darray->store (4, entity_prop_name_v); // vector only has 1 element
  return darray;
}

// TBR: dbeGetEntities() can be set to private now that we have dbeGetEntitiesV2()
Vector<void*> *
dbeGetEntitiesV2 (int dbevindex, Vector<int> *exp_ids, int entity_prop_id)
{
  int sz = exp_ids->size ();
  Vector<void*> *res = new Vector<void*>(sz);
  for (int ii = 0; ii < sz; ii++)
    {
      int expIdx = exp_ids->fetch (ii);
      Vector<void*>* ents = dbeGetEntities (dbevindex, expIdx, entity_prop_id);
      res->store (ii, ents);
    }
  return res;
}

//YXXX old-tl packets still used for details
static Vector<void*> *
getTLDetailValues (int dbevindex, Experiment * exp, int data_id,
                   VMode view_mode, DataView *packets, long idx)
{
  Vector<long long> *value = new Vector<long long>(15);
  long i = idx;
  if (data_id == DATA_SAMPLE || data_id == DATA_GCEVENT)
    {
      //YXXX DATA_SAMPLE not handled but could be.
    }
  Obj stack = (unsigned long) getStack (view_mode, packets, i);
  Vector<Obj> *funcs = stack ? dbeGetStackFunctions (dbevindex, stack) : NULL;
  Function *func = (Function*)
          getStackPC (0, view_mode, packets, i)->convertto (Histable::FUNCTION);
  // Fill common data
  value->store (0, packets->getIntValue (PROP_LWPID, i));
  value->store (1, packets->getIntValue (PROP_THRID, i));
  value->store (2, packets->getIntValue (PROP_CPUID, i));
  value->store (3, packets->getLongValue (PROP_TSTAMP, i));
  value->store (4, (unsigned long) stack);
  value->store (5, (unsigned long) func);

  // Fill specific data
  switch (data_id)
    {
    case DATA_CLOCK:
      value->store (6, packets->getIntValue (PROP_MSTATE, i));
      {
        hrtime_t interval = exp->get_params ()->ptimer_usec * 1000LL // nanoseconds
                * packets->getLongValue (PROP_NTICK, i);
        value->store (7, interval);
      }
      value->store (8, packets->getIntValue (PROP_OMPSTATE, i));
      value->store (9, packets->getLongValue (PROP_EVT_TIME, i)); // visual duration
      break;
    case DATA_SYNCH:
      value->store (6, packets->getLongValue (PROP_EVT_TIME, i));
      value->store (7, packets->getLongValue (PROP_SOBJ, i));
      break;
    case DATA_HWC:
      value->store (6, packets->getLongValue (PROP_HWCINT, i));
      value->store (7, packets->getLongValue (PROP_VADDR, i)); // data vaddr
      value->store (8, packets->getLongValue (PROP_PADDR, i)); // data paddr
      value->store (9, packets->getLongValue (PROP_VIRTPC, i)); // pc paddr
      value->store (10, packets->getLongValue (PROP_PHYSPC, i)); // pc vaddr
      break;
    case DATA_RACE:
      value->store (6, packets->getIntValue (PROP_RTYPE, i));
      value->store (7, packets->getIntValue (PROP_RID, i));
      value->store (8, packets->getLongValue (PROP_RVADDR, i));
      break;
    case DATA_DLCK:
      value->store (6, packets->getIntValue (PROP_DTYPE, i));
      value->store (7, packets->getIntValue (PROP_DLTYPE, i));
      value->store (8, packets->getIntValue (PROP_DID, i));
      value->store (9, packets->getLongValue (PROP_DVADDR, i));
      break;
    case DATA_HEAP:
    case DATA_HEAPSZ:
      value->store (6, packets->getIntValue (PROP_HTYPE, i));
      value->store (7, packets->getLongValue (PROP_HSIZE, i));
      value->store (8, packets->getLongValue (PROP_HVADDR, i));
      value->store (9, packets->getLongValue (PROP_HOVADDR, i));
      value->store (10, packets->getLongValue (PROP_HLEAKED, i));
      value->store (11, packets->getLongValue (PROP_HFREED, i));
      value->store (12, packets->getLongValue (PROP_HCUR_ALLOCS, i)); // signed int64_t
      value->store (13, packets->getLongValue (PROP_HCUR_LEAKS, i));
      break;
    case DATA_IOTRACE:
      value->store (6, packets->getIntValue (PROP_IOTYPE, i));
      value->store (7, packets->getIntValue (PROP_IOFD, i));
      value->store (8, packets->getLongValue (PROP_IONBYTE, i));
      value->store (9, packets->getLongValue (PROP_EVT_TIME, i));
      value->store (10, packets->getIntValue (PROP_IOVFD, i));
      break;
    }
  Vector<void*> *result = new Vector<void*>(5);
  result->store (0, value);
  result->store (1, funcs); // Histable::Function*
  result->store (2, funcs ? dbeGetFuncNames (dbevindex, funcs) : 0); // formatted func names
  result->store (3, stack ? dbeGetStackPCs (dbevindex, stack) : 0); // Histable::DbeInstr*
  result->store (4, stack ? dbeGetStackNames (dbevindex, stack) : 0); // formatted pc names
  return result;
}

Vector<void*> *
dbeGetTLDetails (int dbevindex, int exp_id, int data_id,
                 int entity_prop_id, Obj event_id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Experiment *exp = dbeSession->get_exp (exp_id < 0 ? 0 : exp_id);
  if (exp == NULL)
    return NULL;
  DataView *packets =
          getTimelinePackets (dbevindex, exp_id, data_id, entity_prop_id);
  if (!packets)
    return NULL;

  VMode view_mode = dbev->get_view_mode ();
  long idx = (long) event_id;
  Vector<void*> *values = getTLDetailValues (dbevindex, exp, data_id, view_mode, packets, idx);
  return values;
}

Vector<Obj> *
dbeGetStackFunctions (int dbevindex, Obj stack)
{
  Vector<Obj> *instrs = dbeGetStackPCs (dbevindex, stack);
  if (instrs == NULL)
    return NULL;
  int stsize = instrs->size ();
  Vector<Obj> *jivals = new Vector<Obj>(stsize);
  for (int i = 0; i < stsize; i++)
    {
      Histable *obj = (Histable*) instrs->fetch (i);
      // if ( obj->get_type() != Histable::LINE ) {//YXXX what is this?
      // Remove the above check: why not do this conversion for lines -
      // otherwise filtering in timeline by function stack in omp user mode is broken
      obj = obj->convertto (Histable::FUNCTION);
      jivals->store (i, (Obj) obj);
    }
  delete instrs;
  return jivals;
}

Vector<void*> *
dbeGetStacksFunctions (int dbevindex, Vector<Obj> *stacks)
{
  long sz = stacks->size ();
  Vector<void*> *res = new Vector<void*>(sz);
  for (int ii = 0; ii < sz; ii++)
    {
      Obj stack = stacks->fetch (ii);
      Vector<Obj> *jivals = dbeGetStackFunctions (dbevindex, stack);
      res->store (ii, jivals);
    }
  return res;
}

Vector<Obj> *
dbeGetStackPCs (int dbevindex, Obj stack)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (stack == 0)
    return NULL;

  bool show_all = dbev->isShowAll ();
  Vector<Histable*> *instrs = CallStack::getStackPCs ((void *) stack, !show_all);
  int stsize = instrs->size ();
  int istart = 0;
  bool showAll = dbev->isShowAll ();
  for (int i = 0; i < stsize - 1; i++)
    {
      Function *func = (Function*) instrs->fetch (i)->convertto (Histable::FUNCTION);
      int ix = func->module->loadobject->seg_idx;
      if (showAll && dbev->get_lo_expand (ix) == LIBEX_API)
        // truncate stack here:  LIBRARY_VISIBILITY if we are using API only but no hide
        istart = i;
    }
  stsize = stsize - istart;
  Vector<Obj> *jlvals = new Vector<Obj>(stsize);
  for (int i = 0; i < stsize; i++)
    {
      Histable *instr = instrs->fetch (i + istart);
      jlvals->store (i, (Obj) instr);
    }
  delete instrs;
  return jlvals;
}

Vector<char*> *
dbeGetStackNames (int dbevindex, Obj stack)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  Vector<Obj> *instrs = dbeGetStackPCs (dbevindex, stack);
  if (instrs == NULL)
    return NULL;
  int stsize = instrs->size ();
  Vector<char*> *list = new Vector<char*>(stsize);
  bool showAll = dbev->isShowAll ();
  for (int i = 0; i < stsize; i++)
    {
      Histable* instr = (Histable*) instrs->fetch (i);
      if (!showAll)
        {
          // LIBRARY_VISIBILITY
          Function *func = (Function*) instr->convertto (Histable::FUNCTION);
          LoadObject *lo = ((Function*) func)->module->loadobject;
          if (dbev->get_lo_expand (lo->seg_idx) == LIBEX_HIDE)
            {
              list->store (i, dbe_strdup (lo->get_name ()));
              continue;
            }
        }
      list->store (i, dbe_strdup (instr->get_name (dbev->get_name_format ())));
    }
  delete instrs;
  return list;
}

Vector<void*> *
dbeGetSamples (int dbevindex, int exp_id, int64_t lo_idx, int64_t hi_idx)
{
  DataView * packets =
          getTimelinePackets (dbevindex, exp_id, DATA_SAMPLE, PROP_EXPID);
  if (packets == NULL || packets->getSize () == 0)
    return NULL;
  long lo;
  if (lo_idx < 0)
    lo = 0;
  else
    lo = (long) lo_idx;

  long long max = packets->getSize () - 1;
  long hi;
  if (hi_idx < 0 || hi_idx > max)
    hi = (long) max;
  else
    hi = (long) hi_idx;

  Vector<Vector<long long>*> *sarray = new Vector<Vector<long long>*>;
  Vector<long long>* starts = new Vector<long long>;
  Vector<long long>* ends = new Vector<long long>;
  Vector<long long>* rtimes = new Vector<long long>;
  Vector<char*> *startNames = new Vector<char*>;
  Vector<char*> *endNames = new Vector<char*>;
  Vector<int> *sampId = new Vector<int>;

  for (long index = lo; index <= hi; index++)
    {
      Sample *sample = (Sample*) packets->getObjValue (PROP_SMPLOBJ, index);
      PrUsage *prusage = sample->get_usage ();
      if (prusage == NULL)
        prusage = new PrUsage;
      Vector<long long> *states = prusage->getMstateValues ();
      sarray->append (states);
      starts->append (sample->get_start_time ());
      ends->append (sample->get_end_time ());
      rtimes->append (prusage->pr_rtime);
      startNames->append (dbe_strdup (sample->get_start_label ()));
      endNames->append (dbe_strdup (sample->get_end_label ()));
      sampId->append (sample->get_number ());
    }
  Vector<void *> *res = new Vector<void*>(6);
  res->store (0, sarray);
  res->store (1, starts);
  res->store (2, ends);
  res->store (3, rtimes);
  res->store (4, startNames);
  res->store (5, endNames);
  res->store (6, sampId);
  return res;
}

Vector<void*> *
dbeGetGCEvents (int dbevindex, int exp_id, int64_t lo_idx, int64_t hi_idx)
{
  DataView *packets =
          getTimelinePackets (dbevindex, exp_id, DATA_GCEVENT, PROP_EXPID);
  if (packets == NULL || packets->getSize () == 0)
    return NULL;

  long lo;
  if (lo_idx < 0)
    lo = 0;
  else
    lo = (long) lo_idx;
  long long max = packets->getSize () - 1;
  long hi;
  if (hi_idx < 0 || hi_idx > max)
    hi = (long) max;
  else
    hi = (long) hi_idx;

  Vector<long long>* starts = new Vector<long long>;
  Vector<long long>* ends = new Vector<long long>;
  Vector<int> *eventId = new Vector<int>;
  for (long index = lo; index <= hi; index++)
    {
      GCEvent *gcevent = (GCEvent*) packets->getObjValue (PROP_GCEVENTOBJ, index);
      if (gcevent)
        {
          starts->append (gcevent->start);
          ends->append (gcevent->end);
          eventId->append (gcevent->id);
        }
    }
  Vector<void *> *res = new Vector<void*>(3);
  res->store (0, starts);
  res->store (1, ends);
  res->store (2, eventId);
  return res;
}

Vector<Vector<char*>*>*
dbeGetIOStatistics (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  Hist_data *hist_data;
  Hist_data::HistItem *hi;
  FileData *fDataTotal;

  hist_data = dbev->iofile_data;
  if (hist_data == NULL)
    return NULL;
  hi = hist_data->fetch (0);
  fDataTotal = (FileData*) hi->obj;

  Vector<char*> *writeStat = new Vector<char*>;
  Vector<char*> *readStat = new Vector<char*>;
  Vector<char*> *otherStat = new Vector<char*>;
  Vector<char*> *errorStat = new Vector<char*>;

  writeStat->append (dbe_strdup (GTXT ("Write Statistics")));
  readStat->append (dbe_strdup (GTXT ("Read Statistics")));
  otherStat->append (dbe_strdup (GTXT ("Other I/O Statistics")));
  errorStat->append (dbe_strdup (GTXT ("I/O Error Statistics")));

  StringBuilder sb;
  if (fDataTotal->getWriteCnt () > 0)
    {
      if (fDataTotal->getW0KB1KBCnt () > 0)
        {
          sb.sprintf (GTXT ("0KB - 1KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW0KB1KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW1KB8KBCnt () > 0)
        {
          sb.sprintf (GTXT ("1KB - 8KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW1KB8KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW8KB32KBCnt () > 0)
        {
          sb.sprintf (GTXT ("8KB - 32KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW8KB32KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW32KB128KBCnt () > 0)
        {
          sb.sprintf (GTXT ("32KB - 128KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW32KB128KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW128KB256KBCnt () > 0)
        {
          sb.sprintf (GTXT ("128KB - 256KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW128KB256KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW256KB512KBCnt () > 0)
        {
          sb.sprintf (GTXT ("256KB - 512KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW256KB512KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW512KB1000KBCnt () > 0)
        {
          sb.sprintf (GTXT ("512KB - 1000KB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW512KB1000KBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW1000KB10MBCnt () > 0)
        {
          sb.sprintf (GTXT ("1000KB - 10MB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW1000KB10MBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW10MB100MBCnt () > 0)
        {
          sb.sprintf (GTXT ("10MB - 100MB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW10MB100MBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW100MB1GBCnt () > 0)
        {
          sb.sprintf (GTXT ("100MB - 1GB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW100MB1GBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW1GB10GBCnt () > 0)
        {
          sb.sprintf (GTXT ("1GB - 10GB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW1GB10GBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW10GB100GBCnt () > 0)
        {
          sb.sprintf (GTXT ("10GB - 100GB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW10GB100GBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW100GB1TBCnt () > 0)
        {
          sb.sprintf (GTXT ("100GB - 1TB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW100GB1TBCnt ());
          writeStat->append (sb.toString ());
        }
      if (fDataTotal->getW1TB10TBCnt () > 0)
        {
          sb.sprintf (GTXT ("1TB - 10TB"));
          writeStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getW1TB10TBCnt ());
          writeStat->append (sb.toString ());
        }

      sb.sprintf (GTXT ("Longest write"));
      writeStat->append (sb.toString ());
      sb.sprintf (NTXT ("%.6f (secs.)"),
                  (double) (fDataTotal->getWSlowestBytes () / (double) NANOSEC));
      writeStat->append (sb.toString ());

      sb.sprintf (GTXT ("Smallest write bytes"));
      writeStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getWSmallestBytes ()));
      writeStat->append (sb.toString ());

      sb.sprintf (GTXT ("Largest write bytes"));
      writeStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getWLargestBytes ()));
      writeStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total time"));
      writeStat->append (sb.toString ());
      sb.sprintf (NTXT ("%.6f (secs.)"),
                  (double) (fDataTotal->getWriteTime () / (double) NANOSEC));
      writeStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total calls"));
      writeStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getWriteCnt ()));
      writeStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total bytes"));
      writeStat->append (sb.toString ());
      sb.sprintf (NTXT ("%lld"), (long long) (fDataTotal->getWriteBytes ()));
      writeStat->append (sb.toString ());
    }

  if (fDataTotal->getReadCnt () > 0)
    {
      if (fDataTotal->getR0KB1KBCnt () > 0)
        {
          sb.sprintf (GTXT ("0KB - 1KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR0KB1KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR1KB8KBCnt () > 0)
        {
          sb.sprintf (GTXT ("1KB - 8KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR1KB8KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR8KB32KBCnt () > 0)
        {
          sb.sprintf (GTXT ("8KB - 32KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR8KB32KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR32KB128KBCnt () > 0)
        {
          sb.sprintf (GTXT ("32KB - 128KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR32KB128KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR128KB256KBCnt () > 0)
        {
          sb.sprintf (GTXT ("128KB - 256KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR128KB256KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR256KB512KBCnt () > 0)
        {
          sb.sprintf (GTXT ("256KB - 512KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR256KB512KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR512KB1000KBCnt () > 0)
        {
          sb.sprintf (GTXT ("512KB - 1000KB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR512KB1000KBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR1000KB10MBCnt () > 0)
        {
          sb.sprintf (GTXT ("1000KB - 10MB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR1000KB10MBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR10MB100MBCnt () > 0)
        {
          sb.sprintf (GTXT ("10MB - 100MB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR10MB100MBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR100MB1GBCnt () > 0)
        {
          sb.sprintf (GTXT ("100MB - 1GB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR100MB1GBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR1GB10GBCnt () > 0)
        {
          sb.sprintf (GTXT ("1GB - 10GB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR1GB10GBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR10GB100GBCnt () > 0)
        {
          sb.sprintf (GTXT ("10GB - 100GB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR10GB100GBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR100GB1TBCnt () > 0)
        {
          sb.sprintf (GTXT ("100GB - 1TB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR100GB1TBCnt ());
          readStat->append (sb.toString ());
        }
      if (fDataTotal->getR1TB10TBCnt () > 0)
        {
          sb.sprintf (GTXT ("1TB - 10TB"));
          readStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), fDataTotal->getR1TB10TBCnt ());
          readStat->append (sb.toString ());
        }

      sb.sprintf (GTXT ("Longest read"));
      readStat->append (sb.toString ());
      sb.sprintf (NTXT ("%.6f (secs.)"),
                  (double) (fDataTotal->getRSlowestBytes () / (double) NANOSEC));
      readStat->append (sb.toString ());

      sb.sprintf (GTXT ("Smallest read bytes"));
      readStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getRSmallestBytes ()));
      readStat->append (sb.toString ());

      sb.sprintf (GTXT ("Largest read bytes"));
      readStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getRLargestBytes ()));
      readStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total time"));
      readStat->append (sb.toString ());
      sb.sprintf (NTXT ("%.6f (secs.)"),
                  (double) (fDataTotal->getReadTime () / (double) NANOSEC));
      readStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total calls"));
      readStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getReadCnt ()));
      readStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total bytes"));
      readStat->append (sb.toString ());
      sb.sprintf (NTXT ("%lld"), (long long) (fDataTotal->getReadBytes ()));
      readStat->append (sb.toString ());
    }

  if (fDataTotal->getOtherCnt () > 0)
    {
      sb.sprintf (GTXT ("Total time"));
      otherStat->append (sb.toString ());
      sb.sprintf (NTXT ("%.6f (secs.)"),
                  (double) (fDataTotal->getOtherTime () / (double) NANOSEC));
      otherStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total calls"));
      otherStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getOtherCnt ()));
      otherStat->append (sb.toString ());
    }

  if (fDataTotal->getErrorCnt () > 0)
    {
      sb.sprintf (GTXT ("Total time"));
      errorStat->append (sb.toString ());
      sb.sprintf (NTXT ("%.6f (secs.)"),
                  (double) (fDataTotal->getErrorTime () / (double) NANOSEC));
      errorStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total calls"));
      errorStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (fDataTotal->getErrorCnt ()));
      errorStat->append (sb.toString ());
    }
  Vector<Vector<char*>*>* statisticsData = new Vector<Vector<char*>*>(4);
  statisticsData->store (0, writeStat);
  statisticsData->store (1, readStat);
  statisticsData->store (2, otherStat);
  statisticsData->store (3, errorStat);
  return statisticsData;
}

Vector<Vector<char*>*>*
dbeGetHeapStatistics (int dbevindex)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  Hist_data *hist_data;
  Hist_data::HistItem *hi;
  HeapData *hDataTotal;
  hist_data = dbev->heapcs_data;
  if (hist_data == NULL)
    return NULL;

  hi = hist_data->fetch (0);
  hDataTotal = (HeapData*) hi->obj;
  Vector<char*> *memoryUsage = new Vector<char*>;
  Vector<char*> *allocStat = new Vector<char*>;
  Vector<char*> *leakStat = new Vector<char*>;

  memoryUsage->append (dbe_strdup (GTXT ("Process With Highest Peak Memory Usage")));
  allocStat->append (dbe_strdup (GTXT ("Memory Allocations Statistics")));
  leakStat->append (dbe_strdup (GTXT ("Memory Leaks Statistics")));
  StringBuilder sb;
  if (hDataTotal->getPeakMemUsage () > 0)
    {
      sb.sprintf (GTXT ("Heap size bytes"));
      memoryUsage->append (sb.toString ());
      sb.sprintf (NTXT ("%lld"), (long long) (hDataTotal->getPeakMemUsage ()));
      memoryUsage->append (sb.toString ());

      sb.sprintf (GTXT ("Experiment Id"));
      memoryUsage->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getUserExpId ()));
      memoryUsage->append (sb.toString ());

      sb.sprintf (GTXT ("Process Id"));
      memoryUsage->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getPid ()));
      memoryUsage->append (sb.toString ());

      Vector<hrtime_t> *pTimestamps;
      pTimestamps = hDataTotal->getPeakTimestamps ();
      if (pTimestamps != NULL)
        {
          for (int i = 0; i < pTimestamps->size (); i++)
            {
              sb.sprintf (GTXT ("Time of peak"));
              memoryUsage->append (sb.toString ());
              sb.sprintf (NTXT ("%.3f (secs.)"), (double) (pTimestamps->fetch (i) / (double) NANOSEC));
              memoryUsage->append (sb.toString ());
            }
        }
    }

  if (hDataTotal->getAllocCnt () > 0)
    {
      if (hDataTotal->getA0KB1KBCnt () > 0)
        {
          sb.sprintf (GTXT ("0KB - 1KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA0KB1KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA1KB8KBCnt () > 0)
        {
          sb.sprintf (GTXT ("1KB - 8KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA1KB8KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA8KB32KBCnt () > 0)
        {
          sb.sprintf (GTXT ("8KB - 32KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA8KB32KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA32KB128KBCnt () > 0)
        {
          sb.sprintf (GTXT ("32KB - 128KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA32KB128KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA128KB256KBCnt () > 0)
        {
          sb.sprintf (GTXT ("128KB - 256KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA128KB256KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA256KB512KBCnt () > 0)
        {
          sb.sprintf (GTXT ("256KB - 512KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA256KB512KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA512KB1000KBCnt () > 0)
        {
          sb.sprintf (GTXT ("512KB - 1000KB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA512KB1000KBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA1000KB10MBCnt () > 0)
        {
          sb.sprintf (GTXT ("1000KB - 10MB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA1000KB10MBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA10MB100MBCnt () > 0)
        {
          sb.sprintf (GTXT ("10MB - 100MB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA10MB100MBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA100MB1GBCnt () > 0)
        {
          sb.sprintf (GTXT ("100MB - 1GB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA100MB1GBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA1GB10GBCnt () > 0)
        {
          sb.sprintf (GTXT ("1GB - 10GB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA1GB10GBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA10GB100GBCnt () > 0)
        {
          sb.sprintf (GTXT ("10GB - 100GB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA10GB100GBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA100GB1TBCnt () > 0)
        {
          sb.sprintf (GTXT ("100GB - 1TB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA100GB1TBCnt ());
          allocStat->append (sb.toString ());
        }
      if (hDataTotal->getA1TB10TBCnt () > 0)
        {
          sb.sprintf (GTXT ("1TB - 10TB"));
          allocStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getA1TB10TBCnt ());
          allocStat->append (sb.toString ());
        }

      sb.sprintf (GTXT ("Smallest allocation bytes"));
      allocStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getASmallestBytes ()));
      allocStat->append (sb.toString ());

      sb.sprintf (GTXT ("Largest allocation bytes"));
      allocStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getALargestBytes ()));
      allocStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total allocations"));
      allocStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getAllocCnt ()));
      allocStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total bytes"));
      allocStat->append (sb.toString ());
      sb.sprintf (NTXT ("%lld"), (long long) (hDataTotal->getAllocBytes ()));
      allocStat->append (sb.toString ());
    }

  if (hDataTotal->getLeakCnt () > 0)
    {
      if (hDataTotal->getL0KB1KBCnt () > 0)
        {
          sb.sprintf (GTXT ("0KB - 1KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL0KB1KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL1KB8KBCnt () > 0)
        {
          sb.sprintf (GTXT ("1KB - 8KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL1KB8KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL8KB32KBCnt () > 0)
        {
          sb.sprintf (GTXT ("8KB - 32KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL8KB32KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL32KB128KBCnt () > 0)
        {
          sb.sprintf (GTXT ("32KB - 128KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL32KB128KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL128KB256KBCnt () > 0)
        {
          sb.sprintf (GTXT ("128KB - 256KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL128KB256KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL256KB512KBCnt () > 0)
        {
          sb.sprintf (GTXT ("256KB - 512KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL256KB512KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL512KB1000KBCnt () > 0)
        {
          sb.sprintf (GTXT ("512KB - 1000KB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL512KB1000KBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL1000KB10MBCnt () > 0)
        {
          sb.sprintf (GTXT ("1000KB - 10MB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL1000KB10MBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL10MB100MBCnt () > 0)
        {
          sb.sprintf (GTXT ("10MB - 100MB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL10MB100MBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL100MB1GBCnt () > 0)
        {
          sb.sprintf (GTXT ("100MB - 1GB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL100MB1GBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL1GB10GBCnt () > 0)
        {
          sb.sprintf (GTXT ("1GB - 10GB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL1GB10GBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL10GB100GBCnt () > 0)
        {
          sb.sprintf (GTXT ("10GB - 100GB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL10GB100GBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL100GB1TBCnt () > 0)
        {
          sb.sprintf (GTXT ("100GB - 1TB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL100GB1TBCnt ());
          leakStat->append (sb.toString ());
        }
      if (hDataTotal->getL1TB10TBCnt () > 0)
        {
          sb.sprintf (GTXT ("1TB - 10TB"));
          leakStat->append (sb.toString ());
          sb.sprintf (NTXT ("%d"), hDataTotal->getL1TB10TBCnt ());
          leakStat->append (sb.toString ());
        }

      sb.sprintf (GTXT ("Smallest leaked bytes"));
      leakStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getLSmallestBytes ()));
      leakStat->append (sb.toString ());

      sb.sprintf (GTXT ("Largest leaked bytes"));
      leakStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getLLargestBytes ()));
      leakStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total leaked"));
      leakStat->append (sb.toString ());
      sb.sprintf (NTXT ("%d"), (int) (hDataTotal->getLeakCnt ()));
      leakStat->append (sb.toString ());

      sb.sprintf (GTXT ("Total bytes"));
      leakStat->append (sb.toString ());
      sb.sprintf (NTXT ("%lld"), (long long) (hDataTotal->getLeakBytes ()));
      leakStat->append (sb.toString ());
    }
  Vector<Vector<char*>*>* statisticsData = new Vector<Vector<char*>*>(3);
  statisticsData->store (0, memoryUsage);
  statisticsData->store (1, allocStat);
  statisticsData->store (2, leakStat);
  return statisticsData;
}

Vector<char*> *
dbeGetFuncNames (int dbevindex, Vector<Obj> *funcs)
{
  int len = funcs->size ();
  Vector<char*> *list = new Vector<char*>(len);
  for (int i = 0; i < len; i++)
    list->store (i, dbeGetFuncName (dbevindex, funcs->fetch (i))); // no strdup()
  return list;
}

Vector<char*> *
dbeGetObjNamesV2 (int dbevindex, Vector<uint64_t> *ids)
{
  int len = ids->size ();
  Vector<char*> *list = new Vector<char*>(len);
  for (int i = 0; i < len; i++)
    list->store (i, dbeGetObjNameV2 (dbevindex, ids->fetch (i))); // no strdup()
  return list;
}

char *
dbeGetFuncName (int dbevindex, Obj func)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (func == 0)
    return NULL;
  char *fname;
  fname = ((Histable *) func)->get_name (dbev->get_name_format ());
  return fname ? dbe_strdup (fname) : NULL;
}

Vector<uint64_t> *
dbeGetFuncIds (int dbevindex, Vector<Obj> *funcs)
{
  int len = funcs->size ();
  Vector<uint64_t> *list = new Vector<uint64_t>(len);
  for (int i = 0; i < len; i++)
    list->store (i, dbeGetFuncId (dbevindex, funcs->fetch (i)));
  return list;
}

uint64_t
dbeGetFuncId (int dbevindex, Obj func)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  if (func == 0)
    return 0;
  uint64_t id = ((Histable *) func)->id;
  return id;
}

char *
dbeGetObjNameV2 (int dbevindex, uint64_t id)
{
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Histable *obj = dbeSession->findObjectById (id);
  if (obj == NULL)
    return NULL;
  char *fname = obj->get_name (dbev->get_name_format ());
  return fname ? dbe_strdup (fname) : NULL;
}

char *
dbeGetDataspaceTypeDesc (int /*dbevindex*/, Obj stack)
{
  if (stack == 0)
    return NULL;
  Histable *hist = CallStack::getStackPC ((void *) stack, 0);
  DbeInstr *instr;
  Histable::Type type = hist->get_type ();
  if (type != Histable::INSTR)
    return NULL;
  else
    instr = (DbeInstr *) hist;
  char *descriptor = instr->get_descriptor ();
  return descriptor ? dbe_strdup (descriptor) : NULL;
}

Vector<void*> *
dbeGetDataDescriptorsV2 (int exp_id)
{
  Experiment *exp = dbeSession->get_exp (exp_id);
  if (exp == NULL)
    return NULL;
  Vector<int> *dataId = new Vector<int>;
  Vector<char*> *dataName = new Vector<char*>;
  Vector<char*> *dataUName = new Vector<char*>;
  Vector<int> *auxProp = new Vector<int>;
  Vector<DataDescriptor*> *ddscr = exp->getDataDescriptors ();
  for (int i = 0; i < ddscr->size (); i++)
    {
      DataDescriptor *dataDscr = ddscr->fetch (i);
      if (dataDscr->getFlags () & DDFLAG_NOSHOW)
        continue;
      int data_id = dataDscr->getId ();
      int aux_prop_id = (data_id == DATA_HWC) ? PROP_HWCTAG : PROP_NONE;
      dataId->append (data_id);
      dataName->append (strdup (dataDscr->getName ()));
      dataUName->append (strdup (dataDscr->getUName ()));
      auxProp->append (aux_prop_id);
    }
  delete ddscr;
  Vector<void*> *res = new Vector<void*>(3);
  res->store (0, dataId);
  res->store (1, dataName);
  res->store (2, dataUName);
  res->store (3, auxProp);
  return res;
}

Vector<void*> *
dbeGetDataPropertiesV2 (int exp_id, int data_id)
{
  Experiment *exp = dbeSession->get_exp (exp_id);
  if (exp == NULL)
    return NULL;
  DataDescriptor *dataDscr = exp->get_raw_events (data_id);
  if (dataDscr == NULL)
    return NULL;
  Vector<PropDescr*> *props = dataDscr->getProps ();
  Vector<int> *propId = new Vector<int>(props->size ());
  Vector<char*> *propUName = new Vector<char*>(props->size ());
  Vector<int> *propTypeId = new Vector<int>(props->size ());
  Vector<char*> *propTypeName = new Vector<char*>(props->size ());
  Vector<int> *propFlags = new Vector<int>(props->size ());
  Vector<char*> *propName = new Vector<char*>(props->size ());
  Vector<void*> *propStateNames = new Vector<void*>(props->size ());
  Vector<void*> *propStateUNames = new Vector<void*>(props->size ());

  for (int i = 0; i < props->size (); i++)
    {
      PropDescr *prop = props->fetch (i);
      char *pname = prop->name;
      if (pname == NULL)
        pname = NTXT ("");
      char *uname = prop->uname;
      if (uname == NULL)
        uname = pname;
      int vtypeNum = prop->vtype;
      if (vtypeNum < 0 || vtypeNum >= TYPE_LAST)
        vtypeNum = TYPE_NONE;
      const char * vtypeNames[] = VTYPE_TYPE_NAMES;
      const char *vtype = vtypeNames[prop->vtype];
      Vector<char*> *stateNames = NULL;
      Vector<char*> *stateUNames = NULL;
      int nStates = prop->getMaxState ();
      if (nStates > 0)
        {
          stateNames = new Vector<char*>(nStates);
          stateUNames = new Vector<char*>(nStates);
          for (int kk = 0; kk < nStates; kk++)
            {
              const char * stateName = prop->getStateName (kk);
              stateNames->store (kk, dbe_strdup (stateName));
              const char * Uname = prop->getStateUName (kk);
              stateUNames->store (kk, dbe_strdup (Uname));
            }
        }
      propId->store (i, prop->propID);
      propUName->store (i, dbe_strdup (uname));
      propTypeId->store (i, prop->vtype);
      propTypeName->store (i, dbe_strdup (vtype));
      propFlags->store (i, prop->flags);
      propName->store (i, dbe_strdup (pname));
      propStateNames->store (i, stateNames);
      propStateUNames->store (i, stateUNames);
    }
  Vector<void*> *res = new Vector<void*>(7);
  res->store (0, propId);
  res->store (1, propUName);
  res->store (2, propTypeId);
  res->store (3, propTypeName);
  res->store (4, propFlags);
  res->store (5, propName);
  res->store (6, propStateNames);
  res->store (7, propStateUNames);
  return res;
}

Vector<void *> *
dbeGetExperimentTimeInfo (Vector<int> *exp_ids)
{
  int sz = exp_ids->size ();
  Vector<long long> *offset_time = new Vector<long long> (sz);
  Vector<long long> *start_time = new Vector<long long> (sz);
  Vector<long long> *end_time = new Vector<long long> (sz);
  Vector<long long> *start_wall_sec = new Vector<long long> (sz);
  Vector<char* > *hostname = new Vector<char*> (sz);
  Vector<int> *cpu_freq = new Vector<int> (sz);
  for (int ii = 0; ii < sz; ii++)
    {
      int expIdx = exp_ids->fetch (ii);
      { // update end_time by forcing fetch of experiment data
        // workaround until dbeGetEndTime() is more robust
        int id = (expIdx < 0) ? 0 : expIdx;
        Experiment *exp = dbeSession->get_exp (id);
        if (exp)
          {
            Vector<DataDescriptor*> *ddscr = exp->getDataDescriptors ();
            delete ddscr;
          }
      }
      offset_time->store (ii, dbeGetRelativeStartTime (0, expIdx));
      start_time->store (ii, dbeGetStartTime (0, expIdx));
      end_time->store (ii, dbeGetEndTime (0, expIdx));
      start_wall_sec->store (ii, dbeGetWallStartSec (0, expIdx));
      hostname->store (ii, dbeGetHostname (0, expIdx));
      cpu_freq->store (ii, dbeGetClock (0, expIdx));
    }
  Vector<void*> *res = new Vector<void*>(4);
  res->store (0, offset_time);
  res->store (1, start_time);
  res->store (2, end_time);
  res->store (3, start_wall_sec);
  res->store (4, hostname);
  res->store (5, cpu_freq);
  return res;
}

Vector<void *> *
dbeGetExperimentDataDescriptors (Vector<int> *exp_ids)
{
  int sz = exp_ids->size ();
  Vector<void*> *exp_dscr_info = new Vector<void*> (sz);
  Vector<void*> *exp_dscr_props = new Vector<void*> (sz);

  for (int ii = 0; ii < sz; ii++)
    {
      int expIdx = exp_ids->fetch (ii);
      Vector<void*> *ddscrInfo = dbeGetDataDescriptorsV2 (expIdx);
      Vector<void*> *ddscrProps = new Vector<void*> (); // one entry per ddscrInfo
      if (ddscrInfo)
        {
          Vector<int> *dataId = (Vector<int>*)ddscrInfo->fetch (0);
          if (dataId)
            {
              // loop thru data descriptors
              int ndata = dataId->size ();
              for (int j = 0; j < ndata; ++j)
                {
                  Vector<void*> *props = dbeGetDataPropertiesV2 (expIdx, dataId->fetch (j));
                  ddscrProps->store (j, props);
                }
            }
        }
      exp_dscr_info->store (ii, ddscrInfo);
      exp_dscr_props->store (ii, ddscrProps);
    }
  Vector<void*> *res = new Vector<void*>(2);
  res->store (0, exp_dscr_info);
  res->store (1, exp_dscr_props);
  return res;
}

static Vector<void *> *
dbeGetTLDataRepVals (VMode view_mode, hrtime_t start_ts, hrtime_t delta,
                     int numDeltas, DataView*packets,
                     Vector<long> *representativeEvents, bool showDuration);

static bool
dbeHasTLData (int dbevindex, int exp_id, int data_id, int entity_prop_id,
              int entity_prop_value, int aux)
{
  DataView *packets =
          getTimelinePackets (dbevindex, exp_id, data_id, entity_prop_id);
  if (!packets || packets->getSize () == 0)
    return false;
  long start_ind = getIdxByVals (packets, aux, entity_prop_value,
                                 0, DataView::REL_GTEQ); // time >= 0
  if (start_ind < 0)
    return false;

  DbeView *dbev = dbeSession->getView (dbevindex);
  VMode view_mode = dbev->get_view_mode ();
  Experiment *exp = dbeSession->get_exp (exp_id);
  if (!hasInvisbleTLEvents (exp, view_mode))
    return true; // all events are visible, no further checking required
  long end_ind = getIdxByVals (packets, aux, entity_prop_value,
                               MAX_TIME, DataView::REL_LTEQ);
  for (long ii = start_ind; ii <= end_ind; ii++)
    {
      if (!isVisibleTLEvent (exp, view_mode, packets, ii))
        continue;
      return true; // first visible packet => has data
    }
  return false;
}

Vector<bool> *
dbeHasTLData (int dbev_index, Vector<int> *exp_ids, Vector<int> *data_ids,
              Vector<int> *entity_prop_ids, // LWP,CPU,THR, etc
              Vector<int> *entity_prop_values, Vector<int> *auxs)
{
  DbeView *dbev = dbeSession->getView (dbev_index);
  if (!dbev->isShowAll () && (dbev->isShowHideChanged ()
                              || dbev->isNewViewMode ()))
    {
      // LIBRARY_VISIBILITY
      dbev->resetAndConstructShowHideStacks ();
      if (dbev->isNewViewMode ())
        dbev->resetNewViewMode ();
      if (dbev->isShowHideChanged ())
        dbev->resetShowHideChanged ();
    }

  int sz = exp_ids->size ();
  Vector<bool> *hasVec = new Vector<bool>(sz);
  for (int ii = 0; ii < sz; ii++)
    {
      bool hasData = dbeHasTLData (dbev_index, exp_ids->fetch (ii),
                                   data_ids->fetch (ii),
                                   entity_prop_ids->fetch (ii),
                                   entity_prop_values->fetch (ii),
                                   auxs->fetch (ii));
      hasVec->store (ii, hasData);
    }
  return hasVec;
}

/*
 *   dbeGetTLData implements:
 *   FROM data_id
 *     DURATION >= delta AND ( start_ts <= TSTAMP < start_ts+num*delta OR
 *                             start_ts <= TSTAMP-DURATION < start_ts+num*delta )
 *     OR
 *     FAIR( DURATION < delta AND ( start_ts <= TSTAMP < start_ts+num*delta ) )
 *     WHERE lfilter
 */

Vector<void *> *
dbeGetTLData (
              int dbevindex,
              int exp_id,
              int data_id, // DATA_*
              int entity_prop_id, // Show PROP_LWPID, PROP_CPUID, PROP_THRID, PROP_EXPID, or N/A
              int entity_prop_value, // which LWPID, CPUID, THRID, EXPID for this request
              int aux,
              hrtime_t param_start_ts,
              hrtime_t param_delta,
              int param_numDeltas,
              bool getRepresentatives, // fetch TL representatives
              Vector<char *> *chartProps) // calculate sums for these property vals
{
  const hrtime_t start_ts = param_start_ts;
  const hrtime_t delta = param_delta;
  const int numDeltas = param_numDeltas;
  DbeView *dbev = dbeSession->getView (dbevindex);
  if (dbev == NULL)
    abort ();
  Experiment *exp = dbeSession->get_exp (exp_id);
  if (exp == NULL)
    return NULL;
  if (getRepresentatives == false && chartProps == NULL)
    return NULL;
  if (delta <= 0)
    return NULL;

  hrtime_t tmp_ts = start_ts + delta * numDeltas;
  if (tmp_ts < start_ts)
    tmp_ts = MAX_TIME;
  const hrtime_t end_ts = tmp_ts;
  if (exp->get_status () == Experiment::INCOMPLETE &&
      exp->getLastEvent () < end_ts)
    exp->update ();
  DataView *packets =
          getTimelinePackets (dbevindex, exp_id, data_id, entity_prop_id);
  if (packets == NULL)
    return NULL; // strange, no data view?

  VMode view_mode = dbev->get_view_mode (); // user, expert, machine //YXXX yuck

  // storage for calculating timeline representative events
  Vector<long> *representativeEvents = NULL;
  // list of representative events to be displayed on TL
  Vector<int> *binRepIdx = NULL;
  // for each bin, index    of current "best" representativeEvent
  Vector<void*> *representativeVals = NULL;
  // TL representative packets' values

  // storage for calculating charts
  Vector<int> *propIds = NULL; // [propIdx], which prop to measure
  Vector<void*> *propVals = NULL; // [propIdx][bin], prop vals
  Vector<int> *propNumStates = NULL; // [propIdx], how many states for prop?
  Vector<bool> *propCumulativeChart = NULL; // [propIdx], data represents cumulative totals
  Vector<long long> *propCumulativeRecentBinLastVal = NULL; // [propIdx], most recent value
  Vector<long long> *propCumulativeRecentBinHighVal = NULL; // [propIdx], highest value for propCumulativeRecentBin
  Vector<int> *propCumulativeRecentBin = NULL; // [propIdx], most recent bin

  // determine when to show duration of events
  bool tmp_repsShowDuration = false;
  bool tmp_statesUseDuration = false;
  bool tmp_extendMicrostates = false;
  const hrtime_t ptimerTickDuration = exp->get_params ()->ptimer_usec * 1000LL; // nanoseconds per tick
  const bool hasDuration = packets->getProp (PROP_EVT_TIME) ? true : false;
  if (hasDuration)
    {
      switch (entity_prop_id)
        {
        case PROP_CPUID:
          tmp_repsShowDuration = false;
          tmp_statesUseDuration = false;
          break;
        case PROP_THRID:
        case PROP_LWPID:
          tmp_repsShowDuration = true;
          tmp_statesUseDuration = true;
          tmp_extendMicrostates = (DATA_CLOCK == data_id) && (ptimerTickDuration < param_delta);
          break;
        case PROP_EXPID:
        case PROP_NONE: // experiment summary row uses this
        default:
          if (DATA_SAMPLE == data_id)
            {
              tmp_repsShowDuration = true;
              tmp_statesUseDuration = true;
            }
          else if (DATA_GCEVENT == data_id)
            {
              tmp_repsShowDuration = true;
              tmp_statesUseDuration = true;
            }
          else if (DATA_CLOCK == data_id)
            {
              tmp_repsShowDuration = false;
              tmp_statesUseDuration = true;
              tmp_extendMicrostates = true;
            }
          else
            {
              tmp_repsShowDuration = false;
              tmp_statesUseDuration = true;
            }
          break;
        }
    }
  const bool repsShowDuration = tmp_repsShowDuration; // show stretched callstacks
  const bool statesUseDuration = tmp_statesUseDuration; // use duration to calculate state charts
  const bool extendMicrostates = tmp_extendMicrostates; // we show discrete profiling microstates with
  // width=(tick-1), but for computing
  // zoomed-out graphs we need to extend to
  // account for all ticks, width=(ntick)
  const bool reverseScan = repsShowDuration || extendMicrostates; // scan packets in reverse

  // determine range of packet indices (lo_pkt_idx, hi_pkt_idx)
  long lo_pkt_idx, hi_pkt_idx;
  if (extendMicrostates && !(entity_prop_id == PROP_THRID || entity_prop_id == PROP_LWPID))
    {
      // merging data from multiple threads, need to scan all packets with timestamp [start_ts, exp end]
      hrtime_t exp_end_time = exp->getLastEvent () + 1;
      hi_pkt_idx = getIdxByVals (packets, aux, entity_prop_value,
                                 exp_end_time, DataView::REL_LT); // last item
    }
  else
    hi_pkt_idx = getIdxByVals (packets, aux, entity_prop_value,
                               end_ts, DataView::REL_LT);
  if (repsShowDuration)
    {
      // There are two issues to deal with
      // 1. events that end "off screen" to the right
      // 2. overlapping events

      // 1. events that end "off screen" to the right
      // For now, we only consistently handle the case where events don't overlap.
      // Note that packet timestamps mark end of duration, not start.
      // This means that the rightmost event won't be within hi_pkt_idx.
      // Solution: Check if end+1 packet _started_ in-range
      // Caveat: because we only look ahead by one packet, if there are
      // overlapping duration events (e.g. EXPID aggregation)), zoom level
      // and panning combo may cause events with TSTAMP>end_ts
      // to appear/disappear.  A complete solution would involve
      // a solution to 2.

      // 2. overlapping events
      // For now, we have a simplistic solution that makes "wide" events win.  However,
      // a future solution for deterministically dealing with overlap might look like this:
      // - find all packets that touch the visible time range
      //   - possibly use two DataViews: one with TSTAMP_HI sort and one with TSTAMP_LO
      //     sort to allow efficient determination of packets with HI and LO endpoints in-range
      // - create buckets to  capture "winning" event for each bin (each pixel, that is)
      // - sort the new list of packets by TSTAMP_HI (for example)
      // - looping thru the packets that are in-range, update every bin it touches with it's id
      // - if there is overlap, earlier packets will be kicked out of bins
      // - On the GUI side, paint one event at a time, as normal.
      // - However, for selections, recognize that duration of event may span many bins
      //
      long idx;
      if (hi_pkt_idx >= 0)
        // a packet was found to the left of the end time
        idx = hi_pkt_idx + 1; // attempt to go one packet right
      else
        idx = getIdxByVals (packets, aux, entity_prop_value,
                            end_ts, DataView::REL_GTEQ);
      if (isValidIdx (packets, entity_prop_id, aux, entity_prop_value, idx))
        {
          int64_t pkt_ts = packets->getLongValue (PROP_TSTAMP, idx);
          int64_t duration = packets->getLongValue (PROP_EVT_TIME, idx);
          pkt_ts -= duration;
          if (pkt_ts < end_ts)
            hi_pkt_idx = idx;
        }
    }
  lo_pkt_idx = getIdxByVals (packets, aux, entity_prop_value,
                             start_ts, DataView::REL_GTEQ);

  // allocate structs that return chart data
  bool hasCumulativeCharts = false;
  if (chartProps && chartProps->size () > 0)
    {
      int nprops = chartProps->size ();
      // pre-allocate storage
      propIds = new Vector<int> (nprops);
      propVals = new Vector<void*>(nprops);
      propNumStates = new Vector<int> (nprops);
      propCumulativeChart = new Vector<bool>(nprops);
      propCumulativeRecentBinLastVal = new Vector<long long>(nprops);
      propCumulativeRecentBinHighVal = new Vector<long long>(nprops);
      propCumulativeRecentBin = new Vector<int>(nprops);
      for (int propNum = 0; propNum < nprops; propNum++)
        {
          const char* propStr = chartProps->fetch (propNum);
          int items_per_prop = 0;
          int prop_id = PROP_NONE;
          if (!strcmp (propStr, "EVT_COUNT"))
            items_per_prop = 1; // use PROP_NONE for counting packets
          else
            {
              int lookup_prop_id = dbeSession->getPropIdByName (propStr);
              PropDescr *propDscr = packets->getProp (lookup_prop_id);
              if (propDscr != NULL)
                {
                  switch (propDscr->vtype)
                    {
                    case TYPE_INT32:
                    case TYPE_UINT32:
                    case TYPE_INT64:
                    case TYPE_UINT64:
                      items_per_prop = propDscr->getMaxState () + 1;
                      // add extra slot to store values with out-of-range idx
                      prop_id = lookup_prop_id;
                      break;
                    case TYPE_DOUBLE:
                      break; // not implemented yet
                    case TYPE_STRING:
                    case TYPE_OBJ:
                    case TYPE_DATE:
                    default:
                      break;
                    }
                }
            }
          void *vals;
          if (!items_per_prop)
            vals = NULL;
          else if (items_per_prop == 1)
            {
              Vector<long long> *longVals = new Vector<long long> ();
              longVals->store (numDeltas - 1, 0); // initialize all elements
              vals = longVals;
            }
          else
            {
              Vector<Vector<long long>*> *stateVals =
                      new Vector<Vector<long long>*> ();
              vals = stateVals;
              // initialize only on-demand, some may not be needed
            }

          bool isCumulativeChart;
#define YXXX_HEAP_VS_TIME 1 // YXXX add data meaning to properties?
#if YXXX_HEAP_VS_TIME
          isCumulativeChart = (prop_id == PROP_HCUR_LEAKS || prop_id == PROP_HCUR_ALLOCS);
#endif
          if (isCumulativeChart)
            hasCumulativeCharts = true;
          propIds->store (propNum, prop_id);
          propVals->store (propNum, vals);
          propNumStates->store (propNum, items_per_prop);
          propCumulativeRecentBinLastVal->store (propNum, 0);
          propCumulativeRecentBinHighVal->store (propNum, 0);
          propCumulativeRecentBin->store (propNum, 0);
          propCumulativeChart->store (propNum, isCumulativeChart);
        }
    }

  // Adjust idx range for calculating 'cumulative charts' e.g. heap size
  if (hasCumulativeCharts)
    {
      // set initial values if earlier packet exists
      long lo_idx;
      if (lo_pkt_idx >= 0)
        // packet was found to the right of start
        lo_idx = lo_pkt_idx - 1; // attempt to go left by one event
      else
        // no packet was to the right of start, look left of start
        lo_idx = getIdxByVals (packets, aux, entity_prop_value,
                               start_ts, DataView::REL_LT);
      if (isValidIdx (packets, entity_prop_id, aux, entity_prop_value, lo_idx))
        {
          // preceding packet found
          // update initial values
          int nprops = propCumulativeChart->size ();
          for (int propNum = 0; propNum < nprops; propNum++)
            {
              if (!propCumulativeChart->fetch (propNum))
                continue;
              int propId = propIds->fetch (propNum);
              long long value = packets->getLongValue (propId, lo_idx);
              propCumulativeRecentBinLastVal->store (propNum, value);
              propCumulativeRecentBinHighVal->store (propNum, value);
            }
          // update indices used for iterating
          lo_pkt_idx = lo_idx;
          if (hi_pkt_idx < lo_pkt_idx)
            hi_pkt_idx = lo_pkt_idx;
        }
    }
  if (lo_pkt_idx < 0 || hi_pkt_idx < 0)
    goto dbeGetTLData_done; // no data; return empty vectors, not null

  // representative events (subset of callstacks to represent on TL)
  if (getRepresentatives)
    {
      representativeEvents = new Vector<long>(numDeltas);
      // per-bin, longest event's index
      binRepIdx = new Vector<int>(numDeltas);
      for (int ii = 0; ii < numDeltas; ++ii)
        binRepIdx->append (-1);
    }
  // While packets are sorted by _end_ timestamp (TSTAMP),
  // after calculating start times for non-zero durations,
  // start times are not guaranteed be monotonically increasing.
  // For packets with duration, we'll scan them in reverse order to
  // take advantage of the monotonically decreasing _end_ timestamps.
  long start_idx, idx_inc;
  if (!reverseScan)
    {
      start_idx = lo_pkt_idx;
      idx_inc = 1;
    }
  else
    {
      start_idx = hi_pkt_idx;
      idx_inc = -1;
    }
  for (long ii = start_idx; ii >= lo_pkt_idx && ii <= hi_pkt_idx; ii += idx_inc)
    {
      if (!isVisibleTLEvent (exp, view_mode, packets, ii) && !hasCumulativeCharts)
        continue;

      // determine packet time duration and start bin
      int tmp_start_bin; // packet start bin
      int tmp_end_bin; // packet end bin (inclusive)
      const hrtime_t pkt_end_ts = packets->getLongValue (PROP_TSTAMP, ii);
      const hrtime_t pkt_dur = packets->getLongValue (PROP_EVT_TIME, ii);
      const hrtime_t pkt_start_ts = pkt_end_ts - pkt_dur;
      if (pkt_end_ts < start_ts && !hasCumulativeCharts)
        continue; // weird, should not happen
      if (pkt_start_ts >= end_ts)
        continue; // could happen
      hrtime_t bin_end_ts = pkt_end_ts;
      if (bin_end_ts >= end_ts)
        bin_end_ts = end_ts - 1;
      tmp_end_bin = (int) ((bin_end_ts - start_ts) / delta);
      hrtime_t bin_start_ts = pkt_start_ts;
      if (bin_start_ts < start_ts)
        bin_start_ts = start_ts; // event truncated to left.
      tmp_start_bin = (int) ((bin_start_ts - start_ts) / delta);
      // By definition
      //   (end_ts - start_ts) == delta * numDeltas
      // and we know
      //   pkt_start < end_ts
      // therefore
      //   (pkt_start - start_ts) < delta * numDeltas
      //   (pkt_start - start_ts) / delta < numDeltas
      //   bin < numDeltas
      assert (tmp_end_bin < numDeltas);
      assert (tmp_start_bin < numDeltas);
      const bool is_offscreen = tmp_end_bin < 0 ? true : false;
      if (tmp_end_bin < 0)
        tmp_end_bin = 0;
      const int pkt_end_bin = tmp_end_bin; // packet end bin (inclusive)
      const int pkt_start_bin = tmp_start_bin;
      if (getRepresentatives && !is_offscreen)
        { // find best representative
          // Note: for events with duration, we're scanning packets in order
          // of decreasing end-timestamp.  This means that the first packet
          // that hits a particular _start_ bin will have the longest duration
          // of any later packet that might hit that start bin.  The
          // the first packet will be the best (longest) packet.
          const int bin = reverseScan ? pkt_start_bin : pkt_end_bin;
          int eventIdx = binRepIdx->fetch (bin);
          if (eventIdx == -1)
            {
              eventIdx = representativeEvents->size (); // append to end
              representativeEvents->append (ii);
              binRepIdx->store (bin, eventIdx);
            }
        }
      if (propIds)
        { // per-bin chart: sum across filtered packets
          for (int propNum = 0; propNum < propIds->size (); propNum++)
            {
              void *thisProp = propVals->fetch (propNum);
              if (thisProp == NULL)
                continue; // no valid data
              if (is_offscreen && !propCumulativeChart->fetch (propNum))
                continue; // offscreen events are only processed for cumulative charts
              int propId = propIds->fetch (propNum);
              long long val;
              if (propId == PROP_NONE)
                val = 1; // count
              else
                val = packets->getLongValue (propId, ii);
              long nitems = propNumStates->fetch (propNum);
              if (nitems < 1)
                continue;
              else if (nitems == 1)
                {
                  // chart is not based on not multiple states
                  Vector<long long>* thisPropVals =
                          (Vector<long long>*)thisProp;
                  if (thisPropVals->size () == 0)
                    thisPropVals->store (numDeltas - 1, 0);
                  const int bin = statesUseDuration ? pkt_start_bin : pkt_end_bin;
                  if (!propCumulativeChart->fetch (propNum))
                    {
                      val += thisPropVals->fetch (bin);
                      thisPropVals->store (bin, val);
                    }
                  else
                    {
                      // propCumulativeChart
                      long long high_value = propCumulativeRecentBinHighVal->fetch (propNum);
                      int last_bin = propCumulativeRecentBin->fetch (propNum);
                      if (last_bin < bin)
                        {
                          // backfill from previous event
                          // last_bin: store largest value (in case of multiple events)
                          thisPropVals->store (last_bin, high_value);
                          // propagate forward the bin's last value
                          long long last_value = propCumulativeRecentBinLastVal->fetch (propNum);
                          for (int kk = last_bin + 1; kk < bin; kk++)
                            thisPropVals->store (kk, last_value);
                          // prepare new bin for current event
                          high_value = 0; // high value of next bin is 0.
                          propCumulativeRecentBinHighVal->store (propNum, high_value);
                          propCumulativeRecentBin->store (propNum, bin);
                        }
                      long long this_value = packets->getLongValue (propId, ii);
                      propCumulativeRecentBinLastVal->store (propNum, this_value);
                      if (high_value < this_value)
                        {
                          // record the max
                          high_value = this_value;
                          propCumulativeRecentBinHighVal->store (propNum, high_value);
                        }
                      if (ii == hi_pkt_idx)
                        {
                          // bin: show largest value (in case of multiple events
                          thisPropVals->store (bin, high_value);
                          //forward fill remaining bins
                          for (int kk = bin + 1; kk < numDeltas; kk++)
                            thisPropVals->store (kk, this_value);
                        }
                    }
                }
              else
                {
                  // means val is actually a state #
                  Vector<Vector<long long>*>* thisPropStateVals =
                          (Vector<Vector<long long>*>*)thisProp;
                  if (thisPropStateVals->size () == 0)
                    thisPropStateVals->store (numDeltas - 1, 0);
                  long stateNum;
                  if (val >= 0 && val < nitems)
                    stateNum = (long) val;
                  else
                    stateNum = nitems - 1; // out of range, use last slot
                  hrtime_t graph_pkt_dur = pkt_dur;
                  hrtime_t graph_pkt_start_ts = pkt_start_ts;
                  int tmp2_start_bin = pkt_start_bin;
                  if (propId == PROP_MSTATE)
                    {
                      if (statesUseDuration && extendMicrostates)
                        {
                          // microstate stacks are shown and filtered with width=NTICK-1
                          // but for microstate graph calcs use width=NTICK.
                          graph_pkt_dur += ptimerTickDuration;
                          graph_pkt_start_ts -= ptimerTickDuration;
                          hrtime_t bin_start_ts = graph_pkt_start_ts;
                          if (bin_start_ts < start_ts)
                            bin_start_ts = start_ts; // event truncated to left.
                          tmp2_start_bin = (int) ((bin_start_ts - start_ts) / delta);
                        }
                    }
                  const int graph_pkt_start_bin = statesUseDuration ? tmp2_start_bin : pkt_end_bin;

                  // We will distribute the state's presence evenly over duration of the event.
                  // When only a 'partial bin' is touched by an event, adjust accordingly.
                  long long value_per_bin; // weight to be applied to each bin
                  {
                    long long weight;
                    if (propId == PROP_MSTATE)  // ticks to nanoseconds
                      weight = packets->getLongValue (PROP_NTICK, ii) * ptimerTickDuration;
                    else if (graph_pkt_dur)
                      weight = graph_pkt_dur; // nanoseconds
                    else
                      weight = 1; // no duration; indicate presence
                    if (graph_pkt_start_bin != pkt_end_bin)
                      {
                        // spans multiple bins
                        double nbins = (double) graph_pkt_dur / delta;
                        value_per_bin = weight / nbins;
                      }
                    else
                      value_per_bin = weight;
                  }
                  for (int evtbin = graph_pkt_start_bin; evtbin <= pkt_end_bin; evtbin++)
                    {
                      Vector<long long>* stateValues =
                              (Vector<long long>*) thisPropStateVals->fetch (evtbin);
                      if (stateValues == NULL)
                        {
                          // on-demand storage
                          stateValues = new Vector<long long>(nitems);
                          stateValues->store (nitems - 1, 0); // force memset of full vector
                          thisPropStateVals->store (evtbin, stateValues);
                        }
                      long long new_val = stateValues->fetch (stateNum);
                      if (graph_pkt_start_bin == pkt_end_bin ||
                          (evtbin > graph_pkt_start_bin && evtbin < pkt_end_bin))
                        {
                          new_val += value_per_bin;
                        }
                      else
                        {
                          // partial bin
                          const hrtime_t bin_start = start_ts + evtbin * delta;
                          const hrtime_t bin_end = start_ts + (evtbin + 1) * delta - 1;
                          if (evtbin == graph_pkt_start_bin)
                            {
                              // leftmost bin
                              if (graph_pkt_start_ts < bin_start)
                                new_val += value_per_bin;
                              else
                                {
                                  double percent = (double) (bin_end - graph_pkt_start_ts) / delta;
                                  new_val += value_per_bin*percent;
                                }
                            }
                          else
                            {
                              // rightmost bin
                              if (pkt_end_ts > bin_end)
                                new_val += value_per_bin;
                              else
                                {
                                  double percent = (double) (pkt_end_ts - bin_start) / delta;
                                  new_val += value_per_bin*percent;
                                }
                            }
                        }
                      stateValues->store (stateNum, new_val);
                    }
                }
            }
        }
    }
  delete binRepIdx;
  delete propIds;
  delete propCumulativeChart;
  delete propCumulativeRecentBinLastVal;
  delete propCumulativeRecentBinHighVal;
  delete propCumulativeRecentBin;
  if (representativeEvents != NULL && reverseScan)
    {
      if (repsShowDuration)
        {
          //YXXX for now prune here, but in the future, let gui decide what to show
          // Prune events that are completely obscured long duration events.
          // Note: representativeEvents is sorted by decreasing _end_ timestamps.
          Vector<long> *prunedEvents = new Vector<long>(numDeltas);
          hrtime_t prev_start_ts = MAX_TIME;
          long repCnt = representativeEvents->size ();
          for (long kk = 0; kk < repCnt; kk++)
            {
              long ii = representativeEvents->fetch (kk);
              hrtime_t tmp_end_ts = packets->getLongValue (PROP_TSTAMP, ii);
              hrtime_t tmp_dur = packets->getLongValue (PROP_EVT_TIME, ii);
              hrtime_t tmp_start_ts = tmp_end_ts - tmp_dur;
              if (tmp_start_ts >= prev_start_ts)
                // this event would be completely hidden
                // (because of sorting, we know tmp_end_ts <= prev_end_ts)
                continue;
              prev_start_ts = tmp_start_ts;
              prunedEvents->append (ii);
            }
          // invert order to to get increasing _end_ timestamps
          representativeEvents->reset ();
          for (long kk = prunedEvents->size () - 1; kk >= 0; kk--)
            {
              long packet_idx = prunedEvents->fetch (kk);
              representativeEvents->append (packet_idx);
            }
          delete prunedEvents;
        }
      else
        { // !repsShowDuration
          // Note: representativeEvents is sorted by decreasing _end_ timestamps.
          // Reverse the order:
          long hi_idx = representativeEvents->size () - 1;
          long lo_idx = 0;
          while (hi_idx > lo_idx)
            {
              // swap
              long lo = representativeEvents->fetch (lo_idx);
              long hi = representativeEvents->fetch (hi_idx);
              representativeEvents->store (lo_idx, hi);
              representativeEvents->store (hi_idx, lo);
              hi_idx--;
              lo_idx++;
            }
        }
    }

dbeGetTLData_done:
  if (getRepresentatives)
    {
      representativeVals = dbeGetTLDataRepVals (view_mode, start_ts, delta,
                    numDeltas, packets, representativeEvents, repsShowDuration);
      delete representativeEvents;
    }
  Vector<void*> *results = new Vector<void*> (2);
  results->store (0, representativeVals);
  results->store (1, propVals);
  return results;
}

// add representative events to return buffer

static Vector<void *> *
dbeGetTLDataRepVals (VMode view_mode, hrtime_t start_ts, hrtime_t delta,
                     int numDeltas, DataView*packets,
                     Vector<long> *representativeEvents, bool showDuration)
{
  int numrecs = representativeEvents ? representativeEvents->size () : 0;
  // allocate storage for results
  Vector<int> *startBins = new Vector<int>(numrecs);
  Vector<int> *numBins = new Vector<int>(numrecs);
  Vector<Obj> *eventIdxs = new Vector<Obj>(numrecs);
  Vector<Obj> *stackIds = NULL;
  if (packets->getProp (PROP_FRINFO))
    stackIds = new Vector<Obj>(numrecs);
  Vector<int> *mstates = NULL;
  if (packets->getProp (PROP_MSTATE))
    mstates = new Vector<int>(numrecs);
  Vector<Vector<long long>*> *sampleVals = NULL;
  if (packets->getProp (PROP_SMPLOBJ))
    sampleVals = new Vector<Vector<long long>*>(numrecs);
  Vector<long long> *timeStart = new Vector<long long>(numrecs);
  Vector<long long> *timeEnd = new Vector<long long>(numrecs);
  int prevEndBin = -1; // make sure we don't overlap bins
  for (int eventIdx = 0; eventIdx < numrecs; eventIdx++)
    {
      long packetIdx = representativeEvents->fetch (eventIdx);
      // long eventId = packets->getIdByIdx( packetIdx );
      const hrtime_t pkt_tstamp = packets->getLongValue (PROP_TSTAMP, packetIdx);
      const hrtime_t pkt_dur = showDuration ? packets->getLongValue (PROP_EVT_TIME, packetIdx) : 0;
      timeStart->store (eventIdx, pkt_tstamp - pkt_dur);
      timeEnd->store (eventIdx, pkt_tstamp);

      // calc startBin
      int startBin = (int) ((pkt_tstamp - pkt_dur - start_ts) / delta);
      if (startBin <= prevEndBin)
        startBin = prevEndBin + 1;
      // calc binCnt
      int endBin = (int) ((pkt_tstamp - start_ts) / delta);
      if (endBin >= numDeltas)
        endBin = numDeltas - 1;
      int binCnt = endBin - startBin + 1;
      prevEndBin = endBin;
      startBins->store (eventIdx, startBin);
      numBins->store (eventIdx, binCnt);
      eventIdxs->store (eventIdx, packetIdx); // store packet's idx
      if (stackIds != NULL)
        {
          void* stackId = getStack (view_mode, packets, packetIdx);
          stackIds->store (eventIdx, (Obj) (unsigned long) stackId);
        }
      if (mstates != NULL)
        {
          int mstate = packets->getIntValue (PROP_MSTATE, packetIdx);
          mstates->store (eventIdx, mstate);
        }
      if (sampleVals != NULL)
        {
          Sample* sample = (Sample*) packets->getObjValue (PROP_SMPLOBJ, packetIdx);
          if (!sample || !sample->get_usage ())
            sample = sample;
          else
            {
              PrUsage* prusage = sample->get_usage ();
              Vector<long long> *mstateVals = prusage->getMstateValues ();
              sampleVals->store (eventIdx, mstateVals);
            }
        }
    }
  // caller responsible for: delete representativeEvents;
  Vector<void*> *results = new Vector<void*> (8);
  results->store (0, startBins);
  results->store (1, numBins);
  results->store (2, eventIdxs);
  results->store (3, stackIds);
  results->store (4, mstates);
  results->store (5, sampleVals);
  results->store (6, timeStart);
  results->store (7, timeEnd);
  return results;
}

// starting from <event_id> packet idx, step <move_count> visible events
// return the resulting idx and that packet's center time, or null if no event.
Vector<long long> *
dbeGetTLEventCenterTime (int dbevindex, int exp_id, int data_id,
                         int entity_prop_id, int entity_prop_val, int aux,
                         long long event_id, long long move_count)
{
  DataView *packets = getTimelinePackets (dbevindex, exp_id, data_id,
                                          entity_prop_id);
  if (packets == NULL)
    return NULL;
  long idx = (long) event_id;

  DbeView *dbev = dbeSession->getView (dbevindex);
  VMode view_mode = dbev->get_view_mode ();
  Experiment *exp = dbeSession->get_exp (exp_id);
  int direction;
  if (move_count == 0)
    direction = 0;
  else if (move_count < 0)
    {
      move_count = -move_count;
      direction = -1;
    }
  else
    direction = 1;
  idx = getTLVisibleIdxByStepping (exp, view_mode, entity_prop_id, packets, aux,
                                   entity_prop_val, idx, move_count, direction);
  if (idx >= 0)
    {
      long long ts = packets->getLongValue (PROP_TSTAMP, idx);
      long long dur = packets->getLongValue (PROP_EVT_TIME, idx);
      long long center = ts - dur / 2;
      Vector<long long> *results = new Vector<long long> (2);
      results->store (0, idx); // result idx
      results->store (1, center); // result timestamp
      return results;
    }
  return NULL;
}

long long
dbeGetTLEventIdxNearTime (int dbevindex, int exp_id, int data_id,
                          int entity_prop_id, int entity_prop_val, int aux,
                          int searchDirection, long long tstamp)
{
  DataView *packets = getTimelinePackets (dbevindex, exp_id, data_id,
                                          entity_prop_id);
  if (packets == NULL)
    return -1;
  DbeView *dbev = dbeSession->getView (dbevindex);
  VMode view_mode = dbev->get_view_mode ();
  Experiment *exp = dbeSession->get_exp (exp_id);
  if (searchDirection < 0)
    {
      int idx = getTLVisibleIdxByVals (exp, view_mode, entity_prop_id,
                                       packets, aux, entity_prop_val, tstamp,
                                       DataView::REL_LTEQ);
      if (idx != -1)
        return idx;
      searchDirection = 1; // couldn't find to left, try to right
    }
  if (searchDirection > 0)
    {
      int idx = getTLVisibleIdxByVals (exp, view_mode, entity_prop_id,
                                       packets, aux, entity_prop_val, tstamp,
                                       DataView::REL_GTEQ);
      if (idx != -1)
        return idx;
      // couldn't find to right, fall through to generic
    }
  // search left and right of timestamp
  long idx1, idx2;
  idx1 = getTLVisibleIdxByVals (exp, view_mode, entity_prop_id,
                                packets, aux, entity_prop_val, tstamp,
                                DataView::REL_LT);
  idx2 = getTLVisibleIdxByVals (exp, view_mode, entity_prop_id,
                                packets, aux, entity_prop_val, tstamp,
                                DataView::REL_GTEQ);
  if (idx1 == -1)
    return idx2;
  else if (idx2 == -1)
    return idx1;

  // both valid, so need to compare to see which is closer
  long long t1 = packets->getLongValue (PROP_TSTAMP, idx1);
  long long t2 = packets->getLongValue (PROP_TSTAMP, idx2);
  long long t2dur = packets->getLongValue (PROP_EVT_TIME, idx2);
  long long delta1 = tstamp - t1; // should always be positive
  long long delta2 = (t2 - t2dur) - tstamp; // if negative, overlaps idx1
  if (delta1 > delta2)
    return idx2;
  else
    return idx1;
}

enum Aggr_type
{
  AGGR_NONE,
  AGGR_FAIR,
  AGGR_MAX,
  AGGR_MIN,
  AGGR_CNT,
  AGGR_SUM,
  AGGR_AVG
};

static Aggr_type
getAggrFunc (char *aname)
{
  Aggr_type agrfn = AGGR_NONE;
  if (aname == NULL)
    return agrfn;
  if (strcmp (aname, NTXT ("FAIR")) == 0)
    agrfn = AGGR_FAIR;
  else if (strcmp (aname, NTXT ("MAX")) == 0)
    agrfn = AGGR_MAX;
  else if (strcmp (aname, NTXT ("MIN")) == 0)
    agrfn = AGGR_MIN;
  else if (strcmp (aname, NTXT ("CNT")) == 0)
    agrfn = AGGR_CNT;
  else if (strcmp (aname, NTXT ("SUM")) == 0)
    agrfn = AGGR_SUM;
  else if (strcmp (aname, NTXT ("AVG")) == 0)
    agrfn = AGGR_AVG;
  return agrfn;
}

static long long
computeAggrVal (DefaultMap<long long, long long> *fval_map, Aggr_type agrfn)
{
  long long aval = 0;
  long cnt = 0;
  Vector<long long> *fvals = fval_map->values ();
  long nvals = fvals->size ();
  for (int i = 0; i < nvals; ++i)
    {
      long long val = fvals->fetch (i);
      switch (agrfn)
        {
        case AGGR_FAIR:
          aval = val;
          break;
        case AGGR_MAX:
          if (aval < val || cnt == 0)
            aval = val;
          break;
        case AGGR_MIN:
          if (aval > val || cnt == 0)
            aval = val;
          break;
        case AGGR_CNT:
          aval = cnt + 1;
          break;
        case AGGR_SUM:
        case AGGR_AVG:
          aval += val;
          break;
        case AGGR_NONE:
          break;
        }
      if (agrfn == AGGR_FAIR)
        break;
      cnt += 1;
    }

  // Finalize aggregation
  if (agrfn == AGGR_AVG)
    if (cnt > 0)
      aval = (aval + cnt / 2) / cnt;
  delete fvals;
  return aval;
}

Vector<long long> *
dbeGetAggregatedValue (int data_id, // data table id
                       char *lfilter, // local filter
                       char *fexpr, // function expression
                       char *pname_ts, // property name for timestamp
                       hrtime_t start_ts, // start of the first time interval
                       hrtime_t delta, // time interval length
                       int num, // number of time intervals
                       char *pname_key, // property name for aggregation key
                       char *aggr_func) // aggregation function
{
  Vector<long long> *res = new Vector<long long>;
  Experiment *exp = dbeSession->get_exp (0);
  if (exp == NULL)
    return res;
  hrtime_t end_ts = start_ts + delta * num;
  if (end_ts < start_ts)    // check overflow
    end_ts = MAX_TIME;

  if (exp->get_status () == Experiment::INCOMPLETE
      && exp->getLastEvent () < end_ts)
    exp->update ();

  DataDescriptor *dataDscr = exp->get_raw_events (data_id);
  if (dataDscr == NULL)
    return res;

  // Process timestamp argument
  int prop_ts = dbeSession->getPropIdByName (pname_ts);
  if (prop_ts == PROP_NONE)
    return res;
  assert (prop_ts == -1);

  // Parse all expressions
  Expression *flt_expr = NULL;
  if (lfilter != NULL)
    flt_expr = dbeSession->ql_parse (lfilter);
  Expression *func_expr = NULL;
  if (fexpr != NULL)
    func_expr = dbeSession->ql_parse (fexpr);
  if (func_expr == NULL)   // Not specified or malformed
    return res;

  // Process aggregation key argument
  int prop_key = PROP_NONE;
  Data *data_key = NULL;
  if (pname_key != NULL)
    {
      prop_key = dbeSession->getPropIdByName (pname_key);
      data_key = dataDscr->getData (prop_key);
      if (data_key == NULL)   // Specified but not found
        return res;
    }

  // Process aggregation function argument
  Aggr_type agrfn = AGGR_FAIR;
  if (aggr_func != NULL)
    {
      agrfn = getAggrFunc (aggr_func);
      if (agrfn == AGGR_NONE) // Specified but not recognized
        return res;
    }
  DefaultMap<long long, long long> *
        fval_map = new DefaultMap<long long, long long>; // key_val -> func_val
  Vector<long long> *key_set = NULL;
  assert (key_set != NULL);
  if (key_set == NULL)
    {
      key_set = new Vector<long long>;
      key_set->append (0L);
    }
  DefaultMap<long long, int> *key_seen = new DefaultMap<long long, int>;
  long idx_prev = -1;
  for (int tidx = 0; tidx < num; ++tidx)
    {
      long idx_cur = -1;
      assert (idx_cur != -1);
      int left = key_set->size ();
      key_seen->clear ();
      for (long idx = idx_cur; idx > idx_prev; --idx)
        {
          long id = 0;
          assert (id != 0);

          // Pre-create expression context
          Expression::Context ctx (dbeSession->getView (0), exp, NULL, id);
          // First use the filter
          if (flt_expr != NULL)
            if (flt_expr->eval (&ctx) == 0)
              continue;

          // Calculate the key
          // keys are limited to integral values
          long long key = 0;
          if (data_key != NULL)
            key = data_key->fetchLong (id);

          // Check if already seen
          if (key_seen->get (key) == 1)
            continue;
          key_seen->put (key, 1);
          left -= 1;

          // Calculate function value
          // function values are limited to integral values
          long long fval = func_expr->eval (&ctx);
          fval_map->put (key, fval);
          if (left == 0)
            break;
        }
      idx_prev = idx_cur;
      long long aval = computeAggrVal (fval_map, agrfn);
      res->store (tidx, aval);
    }
  delete key_seen;
  delete fval_map;
  delete flt_expr;
  delete func_expr;
  return res;
}

Vector<char*> *
dbeGetLineInfo (Obj pc)
{
  DbeInstr *instr = (DbeInstr*) pc;
  if (instr == NULL || instr->get_type () != Histable::INSTR)
    return NULL;
  DbeLine *dbeline = (DbeLine*) instr->convertto (Histable::LINE);
  const char *fname = dbeline ? dbeline->sourceFile->get_name () : NTXT ("");
  char lineno[16];
  *lineno = '\0';
  if (dbeline != NULL)
    snprintf (lineno, sizeof (lineno), NTXT ("%d"), dbeline->lineno);
  Vector<char*> *res = new Vector<char*>(2);
  res->store (0, strdup (fname));
  res->store (1, strdup (lineno));
  return res;
}

int
dbeSetAlias (char *name, char *uname, char *expr)
{
  char *res = dbeSession->indxobj_define (name, uname, expr, NULL, NULL);
  return res == NULL ? 0 : 1;
}

Vector<char*> *
dbeGetAlias (char *name)
{
  Vector<char*> *res = new Vector<char*>;
  int idx = dbeSession->findIndexSpaceByName (name);
  if (idx >= 0)
    {
      char *str = dbeSession->getIndexSpaceDescr (idx);
      res->append (dbe_strdup (str));
      str = dbeSession->getIndexSpaceExprStr (idx);
      res->append (dbe_strdup (str));
    }
  return res;
}

static int
key_cmp (const void *p1, const void *p2)
{
  long long ll1 = *(long long*) p1;
  long long ll2 = *(long long*) p2;
  return ll1 < ll2 ? -1 : ll1 > ll2 ? 1 : 0;
}

Vector<Vector<long long>*> *
dbeGetXYPlotData (
                  int data_id, // data table id
                  char *lfilter, // local filter expression
                  char *arg, // name for the argument
                  char *func1, // expression for the first axis (x)
                  char *aggr1, // aggregation function for func1: "SUM","CNT",...
                  char *func2, // expression for the second axis (y)
                  char *aggr2, // aggregation function for func2
                  char *func3, // expression for the third axis (color)
                  char *aggr3) // aggregation function for func3
{
  Vector<Vector<long long>*> *res = new Vector<Vector<long long>*>;
  Experiment *exp = dbeSession->get_exp (0);
  if (exp == NULL)
    return res;
  if (exp->get_status () == Experiment::INCOMPLETE)
    exp->update ();

  DataDescriptor *dataDscr = exp->get_raw_events (data_id);
  if (dataDscr == NULL)
    return res;

  // Parse all expressions
  Vector<Expression*> *funcs = new Vector<Expression*>;
  Vector<Aggr_type> *aggrs = new Vector<Aggr_type>;
  Vector<DefaultMap<long long, long long>*> *fval_maps =
          new Vector<DefaultMap<long long, long long>*>;
  Vector<DefaultMap<long long, long>*> *cnt_maps =
          new Vector<DefaultMap<long long, long>*>;
  if (func1 != NULL)
    {
      Expression *expr = dbeSession->ql_parse (func1);
      funcs->append (expr);
      aggrs->append (getAggrFunc (aggr1));
      fval_maps->append (new DefaultMap<long long, long long>);
      cnt_maps->append (new DefaultMap<long long, long>);
      res->append (new Vector<long long>);
      if (func2 != NULL)
        {
          expr = dbeSession->ql_parse (func2);
          funcs->append (expr);
          aggrs->append (getAggrFunc (aggr2));
          fval_maps->append (new DefaultMap<long long, long long>);
          cnt_maps->append (new DefaultMap<long long, long>);
          res->append (new Vector<long long>);
          if (func3 != NULL)
            {
              expr = dbeSession->ql_parse (func3);
              funcs->append (expr);
              aggrs->append (getAggrFunc (aggr3));
              fval_maps->append (new DefaultMap<long long, long long>);
              cnt_maps->append (new DefaultMap<long long, long>);
              res->append (new Vector<long long>);
            }
        }
    }
  if (funcs->size () == 0)
    {
      funcs->destroy ();
      delete funcs;
      fval_maps->destroy ();
      delete fval_maps;
      cnt_maps->destroy ();
      delete cnt_maps;
      delete aggrs;
      return res;
    }
  Expression *arg_expr = NULL;
  if (arg != NULL)
    arg_expr = dbeSession->ql_parse (arg);
  if (arg_expr == NULL)
    {
      funcs->destroy ();
      delete funcs;
      fval_maps->destroy ();
      delete fval_maps;
      cnt_maps->destroy ();
      delete cnt_maps;
      delete aggrs;
      return res;
    }
  Expression *flt_expr = NULL;
  if (lfilter != NULL)
    flt_expr = dbeSession->ql_parse (lfilter);
  Vector<long long> *kidx_map = new Vector<long long>(); // key_idx -> key_val
  for (long i = 0; i < dataDscr->getSize (); i++)
    {
      Expression::Context ctx (dbeSession->getView (0), exp, NULL, i);
      // First use the filter
      if (flt_expr != NULL)
        if (flt_expr->eval (&ctx) == 0)
          continue;

      // Compute the argument
      long long key = arg_expr->eval (&ctx);
      if (kidx_map->find (key) == -1)
        kidx_map->append (key);
      for (long j = 0; j < funcs->size (); ++j)
        {
          Expression *func = funcs->fetch (j);
          Aggr_type aggr = aggrs->fetch (j);
          DefaultMap<long long, long long> *fval_map = fval_maps->fetch (j);
          DefaultMap<long long, long> *cnt_map = cnt_maps->fetch (j);
          long long fval = func->eval (&ctx);
          long long aval = fval_map->get (key);
          long cnt = cnt_map->get (key);
          switch (aggr)
            {
            case AGGR_NONE:
            case AGGR_FAIR:
              if (cnt == 0)
                aval = fval;
              break;
            case AGGR_MAX:
              if (aval < fval || cnt == 0)
                aval = fval;
              break;
            case AGGR_MIN:
              if (aval > fval || cnt == 0)
                aval = fval;
              break;
            case AGGR_CNT:
              aval = cnt + 1;
              break;
            case AGGR_SUM:
            case AGGR_AVG:
              aval += fval;
              break;
            }
          cnt_map->put (key, cnt + 1);
          fval_map->put (key, aval);
        }
    }
  kidx_map->sort (key_cmp);

  // Finalize aggregation, prepare result
  for (long j = 0; j < funcs->size (); ++j)
    {
      Aggr_type aggr = aggrs->fetch (j);
      Vector<long long> *resj = res->fetch (j);
      DefaultMap<long long, long long> *
              fval_map = fval_maps->fetch (j);
      DefaultMap<long long, long> *
              cnt_map = cnt_maps->fetch (j);
      for (int kidx = 0; kidx < kidx_map->size (); ++kidx)
        {
          long long key = kidx_map->fetch (kidx);
          long long aval = fval_map->get (key);
          if (aggr == AGGR_AVG)
            {
              long cnt = cnt_map->get (key);
              if (cnt > 0)
                aval = (aval + cnt / 2) / cnt;
            }
          resj->append (aval);
        }
    }
  delete flt_expr;
  funcs->destroy ();
  delete funcs;
  delete aggrs;
  delete arg_expr;
  delete kidx_map;
  fval_maps->destroy ();
  delete fval_maps;
  cnt_maps->destroy ();
  delete cnt_maps;
  return res;
}

/* ********************************************************************* */
/*  Routines for use by Collector GUI */
/**
 * Returns signal value for provided name. Example of name: "SIGUSR1"
 * @param signal
 * @return value
 */
int
dbeGetSignalValue (char *signal)
{
  int ret = -1;
  if (signal == NULL)
    return ret;
  if (strcmp (signal, "SIGUSR1") == 0)
    return (SIGUSR1);
  if (strcmp (signal, "SIGUSR2") == 0)
    return (SIGUSR2);
  if (strcmp (signal, "SIGPROF") == 0)
    return (SIGPROF);
  return ret;
}

char *
dbeSendSignal (pid_t p, int signum)
{
  int ret = kill (p, signum);
  if (p == 0 || p == -1)
    return (dbe_sprintf (GTXT ("kill of process %d not supported\n"), p));
  if (ret == 0)
    return NULL;
  char *msg = dbe_sprintf (GTXT ("kill(%d, %d) failed: %s\n"), p, signum,
                           strerror (errno));
  return msg;
}

char *
dbeGetCollectorControlValue (char *control)
{
  if (control == NULL)
    return NULL;
  if (col_ctr == NULL)
    col_ctr = new Coll_Ctrl (1);
  char *msg = col_ctr->get (control);
  return msg;
}

char *
dbeSetCollectorControlValue (char *control, char * value)
{
  if (control == NULL)
    return NULL;
  if (col_ctr == NULL)
    col_ctr = new Coll_Ctrl (1);
  char *msg = col_ctr->set (control, value);
  return msg;
}

char *
dbeUnsetCollectorControlValue (char *control)
{
  if (control == NULL)
    return NULL;
  if (col_ctr == NULL)
    col_ctr = new Coll_Ctrl (1);
  char *msg = col_ctr->unset (control);
  return msg;
}

void
dbeSetLocation (const char *fname, const char *location)
{
  Vector<SourceFile*> *sources = dbeSession->get_sources ();
  for (long i = 0, sz = sources ? sources->size () : 0; i < sz; i++)
    {
      SourceFile *src = sources->get (i);
      DbeFile *df = src->dbeFile;
      if (df && (strcmp (fname, df->get_name ()) == 0))
        {
          df->find_file ((char *) location);
          break;
        }
    }
}

void
dbeSetLocations (Vector<const char *> *fnames, Vector<const char *> *locations)
{
  if (fnames == NULL || locations == NULL
      || fnames->size () != locations->size ())
    return;
  for (long i = 0, sz = fnames->size (); i < sz; i++)
    dbeSetLocation (fnames->get (i), locations->get (i));
}

Vector<void*> *
dbeResolvedWith_setpath (const char *path)
{
  Vector<char*> *names = new Vector<char*>();
  Vector<char*> *pathes = new Vector<char*>();
  Vector<long long> *ids = new Vector<long long>();
  Vector<SourceFile*> *sources = dbeSession->get_sources ();
  for (long i = 0, sz = sources ? sources->size () : 0; i < sz; i++)
    {
      SourceFile *src = sources->get (i);
      DbeFile *df = src->dbeFile;
      if (df == NULL || (df->filetype & DbeFile::F_FICTION) != 0)
        continue;
      char *fnm = df->get_name ();
      if ((df->filetype & (DbeFile::F_JAVACLASS | DbeFile::F_JAVA_SOURCE)) != 0)
        {
          char *jnm = dbe_sprintf (NTXT ("%s/%s"), path, fnm);
          if (df->check_access (jnm) == DbeFile::F_FILE)
            {
              names->append (dbe_strdup (fnm));
              pathes->append (jnm);
              ids->append (src->id);
              continue;
            }
          free (jnm);
        }
      char *nm = dbe_sprintf (NTXT ("%s/%s"), path, get_basename (fnm));
      if (df->check_access (nm) == DbeFile::F_FILE)
        {
          names->append (dbe_strdup (fnm));
          pathes->append (nm);
          ids->append (src->id);
          continue;
        }
      free (nm);
    }
  if (names->size () != 0)
    {
      Vector<void*> *data = new Vector<void*>(3);
      data->append (names);
      data->append (pathes);
      data->append (ids);
      return data;
    }
  return NULL;
}

Vector<void*> *
dbeResolvedWith_pathmap (const char *old_prefix, const char *new_prefix)
{
  size_t len = strlen (old_prefix);
  Vector<char*> *names = new Vector<char*>();
  Vector<char*> *pathes = new Vector<char*>();
  Vector<long long> *ids = new Vector<long long>();
  Vector<SourceFile*> *sources = dbeSession->get_sources ();
  for (long i = 0, sz = sources ? sources->size () : 0; i < sz; i++)
    {
      SourceFile *src = sources->get (i);
      DbeFile *df = src->dbeFile;
      if (df == NULL || (df->filetype & DbeFile::F_FICTION) != 0)
        continue;
      char *fnm = df->get_name ();
      if (strncmp (old_prefix, fnm, len) == 0
          && (fnm[len] == '/' || fnm[len] == '\0'))
        {
          char *nm = dbe_sprintf (NTXT ("%s/%s"), new_prefix, fnm + len);
          if (df->check_access (nm) == DbeFile::F_FILE)
            {
              names->append (dbe_strdup (fnm));
              pathes->append (nm);
              ids->append (src->id);
              continue;
            }
          if ((df->filetype & DbeFile::F_JAVA_SOURCE) != 0)
            {
              free (nm);
              nm = dbe_sprintf (NTXT ("%s/%s"), new_prefix, fnm);
              if (df->check_access (nm) == DbeFile::F_FILE)
                {
                  names->append (dbe_strdup (fnm));
                  pathes->append (nm);
                  ids->append (src->id);
                  continue;
                }
            }
          free (nm);
        }
    }
  if (names->size () != 0)
    {
      Vector<void*> *data = new Vector<void*>(3);
      data->append (names);
      data->append (pathes);
      data->append (ids);
      return data;
    }
  return NULL;
}

void
dbe_archive (Vector<long long> *ids, Vector<const char *> *locations)
{
  if (ids == NULL || locations == NULL || ids->size () != locations->size ())
    return;
  Experiment *exp = dbeSession->get_exp (0);
  if (exp == NULL)
    return;
  Vector<SourceFile*> *sources = dbeSession->get_sources ();
  for (long i1 = 0, sz1 = ids->size (); i1 < sz1; i1++)
    {
      long long id = ids->get (i1);
      for (long i = 0, sz = sources ? sources->size () : 0; i < sz; i++)
        {
          SourceFile *src = sources->get (i);
          if (src->id == id)
            {
              DbeFile *df = src->dbeFile;
              if (df)
                {
                  char *fnm = df->find_file ((char *) locations->get (i1));
                  if (fnm)
                    {
                      char *nm = df->get_name ();
                      char *anm = exp->getNameInArchive (nm, false);
                      exp->copy_file (fnm, anm, true);
                      free (anm);
                    }
                }
            }
        }
    }
}

/* ************************************************************************ */

/* Routines to check connection between Remote Analyzer Client and er_print */
char *
dbeCheckConnection (char *str)
{
  return dbe_strdup (str);
}