/* Copyright (C) 2021-2023 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
struct stat64 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 (¶ms) == 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);
}