Automatic date update in version.in

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

/* Copyright (C) 2021 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 "util.h"
#include "Command.h"
#include "DbeSession.h"
#include "MetricList.h"
#include "StringBuilder.h"

//  Build a metric reference list
MetricList::MetricList (Vector<BaseMetric*> *base_metrics, MetricType _mtype)
{
  mtype = _mtype;
  items = new Vector<Metric*>;
  sort_ref_index = 0;
  sort_reverse = false;

  Metric *mitem;
  // loop over the base_metrics, and add in all the appropriate subtypes
  for (long i = 0, sz = base_metrics ? base_metrics->size () : 0; i < sz; i++)
    {
      BaseMetric *mtr = base_metrics->get (i);
      if (mtr->is_internal ())
        continue;
      switch (mtype)
        {
        case MET_DATA:
          if ((mtr->get_flavors () & BaseMetric::DATASPACE) != 0)
            {
              mitem = new Metric (mtr, BaseMetric::DATASPACE);
              items->append (mitem);
            }
          break;

        case MET_INDX:
          {
            if ((mtr->get_flavors () & BaseMetric::INCLUSIVE) != 0
                || (mtr->get_flavors () & BaseMetric::EXCLUSIVE) != 0)
              {
                int index2;
                Metric *item2 = NULL;
                bool found = false;
                Vec_loop (Metric*, items, index2, item2)
                {
                  if (item2->get_subtype () == BaseMetric::EXCLUSIVE
                      && dbe_strcmp (item2->get_cmd (), mtr->get_cmd ()) == 0)
                    {
                      found = true;
                      break;
                    }
                }
                if (found == false)
                  {
                    mitem = new Metric (mtr, BaseMetric::EXCLUSIVE);
                    items->append (mitem);
                  }
              }
          }
          break;

        case MET_CALL:
        case MET_CALL_AGR:
          if ((mtr->get_flavors () & BaseMetric::ATTRIBUTED) != 0)
            {
              mitem = new Metric (mtr, BaseMetric::ATTRIBUTED);
              items->append (mitem);
            }
          // now fall through to add exclusive and inclusive

        case MET_NORMAL:
        case MET_COMMON:
          if (mtr->get_flavors () & BaseMetric::EXCLUSIVE)
            {
              mitem = new Metric (mtr, BaseMetric::EXCLUSIVE);
              items->append (mitem);
            }
          if (mtr->get_flavors () & BaseMetric::INCLUSIVE)
            {
              mitem = new Metric (mtr, BaseMetric::INCLUSIVE);
              items->append (mitem);
            }
          break;
        case MET_SRCDIS:
          if (mtr->get_flavors () & BaseMetric::INCLUSIVE)
            {
              mitem = new Metric (mtr, BaseMetric::INCLUSIVE);
              items->append (mitem);
            }
          break;
        case MET_IO:
          {
            if (mtr->get_packet_type () == DATA_IOTRACE
                && ((mtr->get_flavors () & BaseMetric::INCLUSIVE) != 0
                    || (mtr->get_flavors () & BaseMetric::EXCLUSIVE) != 0))
              {
                int index2;
                Metric *item2 = NULL;
                bool found = false;
                Vec_loop (Metric*, items, index2, item2)
                {
                  if (item2->get_subtype () == BaseMetric::EXCLUSIVE
                      && dbe_strcmp (item2->get_cmd (), mtr->get_cmd ()) == 0)
                    {
                      found = true;
                      break;
                    }
                }
                if (found == false)
                  {
                    mitem = new Metric (mtr, BaseMetric::EXCLUSIVE);
                    items->append (mitem);
                  }
              }
          }
          break;
        case MET_HEAP:
          {
            if (mtr->get_packet_type () == DATA_HEAP
                && ((mtr->get_flavors () & BaseMetric::INCLUSIVE) != 0
                    || (mtr->get_flavors () & BaseMetric::EXCLUSIVE) != 0))
              {
                int index2;
                Metric *item2 = NULL;
                bool found = false;
                Vec_loop (Metric*, items, index2, item2)
                {
                  if ((item2->get_subtype () == BaseMetric::EXCLUSIVE) &&
                      (dbe_strcmp (item2->get_cmd (), mtr->get_cmd ()) == 0))
                    {
                      found = true;
                      break;
                    }
                }
                if (found == false)
                  {
                    mitem = new Metric (mtr, BaseMetric::EXCLUSIVE);
                    items->append (mitem);
                  }
              }
          }
          break;
        }

      // add the static
      if (mtr->get_flavors () & BaseMetric::STATIC)
        {
          switch (mtype)
            {
            case MET_NORMAL:
            case MET_COMMON:
            case MET_CALL:
            case MET_CALL_AGR:
            case MET_SRCDIS:
              mitem = new Metric (mtr, BaseMetric::STATIC);
              items->append (mitem);
              break;
            default:
              if (mtr->get_type () == BaseMetric::ONAME)
                {
                  mitem = new Metric (mtr, BaseMetric::STATIC);
                  items->append (mitem);
                }
              break;
            }
        }
    }
  // set all metrics visible
  for (long i = 0, sz = items ? items->size () : 0; i < sz; i++)
    items->get (i)->enable_all_visbits ();
}

// Constructor for an empty list -- items will be added one at a time
MetricList::MetricList (MetricType _mtype)
{
  mtype = _mtype;
  items = new Vector<Metric*>;
  sort_ref_index = 0;
  sort_reverse = false;
}

MetricList::~MetricList ()
{
  Destroy (items);
}

// Duplicate a metric list
MetricList::MetricList (MetricList *old)
{
  mtype = old->mtype;

  // get an empty vector
  items = new Vector<Metric*>;
  Metric *item;
  Metric *nitem;
  int index;
  sort_ref_index = old->get_sort_ref_index ();
  sort_reverse = old->get_sort_rev ();
  Vec_loop (Metric*, old->items, index, item)
  {
    nitem = new Metric (*item);
    items->append (nitem);
  }
}

// set_metrics:
//      Sets the particular metric list, according to the metric spec
//      If fromRcFile, updates dbeSession->get_reg_metrics_tree() with new defaults.
char *
MetricList::set_metrics (const char *mspec, bool fromRcFile,
                         DerivedMetrics * /* derived_metrics */)
{
  BaseMetric::SubType subtypes[10];
  int nsubtypes;
  int dmetrics_vis; // literal translation of metrics/dmetrics %.+
  bool parseOK = false;
  char *errbuf;
  Vector<Metric*> *old_items = items;
  items = new Vector<Metric*>;
  Vector<BaseMetric*> *base_items = dbeSession->get_base_reg_metrics ();

  // and copy the input specification
  char *buf = dbe_strdup (mspec);

  // append metric items from parsing the string
  for (char *mcmd = strtok (buf, NTXT (":")); mcmd != NULL;
          mcmd = strtok (NULL, NTXT (":")))
    {
      // parse the single metric_spec, based on the type of list being constructed, into:
      //        a vector of SubTypes (any of [iead] or STATIC)
      //        a integer mask for the visibility bits
      //        and the string name of the base metric
      //            it might be "all", "any", or "hwc" or it should match a metric in the list
      //            it might also be "bit", meaning any bit-computed metric
      char *mname = parse_metric_spec (mcmd, subtypes, &nsubtypes,
                                       &dmetrics_vis, &parseOK);
      if (!parseOK)
        {
          // error parsing the metric specification
          // not from an rc file, it's an error
          if (!fromRcFile)
            {
              delete base_items;
              items->destroy ();
              delete items;
              items = old_items;
              free (buf);
              return mname;
            }
          continue;
        }

      // loop over subtypes requested
      // set the visibility of and sort order according to the vis bits,
      //        and the order of encounter in the processing
      int ret = add_matching_dmetrics (base_items, mname, subtypes, nsubtypes,
                                       dmetrics_vis, fromRcFile);
      if (ret != 0 && !fromRcFile)
        {
          if (ret == 1)
            errbuf = dbe_sprintf (GTXT ("No data recorded to support metric specification: %s\n"),
                                  mcmd);
          else
            errbuf = dbe_sprintf (GTXT ("Metric specification for `%s' has appeared before in %s"),
                                    mcmd, mspec);
          delete base_items;
          items->destroy ();
          delete items;
          items = old_items;
          free (buf);
          return errbuf;
        }
    } // we've processed the entire spec

  // update metric defaults
  if (fromRcFile)
    {
      for (long i = 0, sz = items->size (); i < sz; i++)
        {
          Metric *m = items->get (i);
          int visbits = m->get_visbits ();
          BaseMetric::SubType subtype = m->get_subtype ();
          BaseMetric *reg_bm = m->get_base_metric ();
          reg_bm->set_default_visbits (subtype, visbits);
          BaseMetricTreeNode *mtree = dbeSession->get_reg_metrics_tree ();
          BaseMetricTreeNode *bmtnode = mtree->register_metric (m);
          BaseMetric *tree_bm = bmtnode->get_BaseMetric ();
          tree_bm->set_default_visbits (subtype, visbits);
        }
    }

  // ensure that name is present, remove hidden metrics
  nsubtypes = 1;
  for (long i = items->size () - 1; i >= 0; i--)
    {
      Metric *m = items->fetch (i);
      if (!m->is_any_visible ())
        {
          delete m;
          items->remove (i);
          continue;
        }
      if (m->get_type () == BaseMetric::ONAME)
        nsubtypes = 0;
    }

  // did we get at least one valid match?
  if (items->size () == 0 && !fromRcFile)
    {
      errbuf = dbe_sprintf (GTXT ("No valid metrics specified in `%s'\n"), mspec);
      delete base_items;
      items->destroy ();
      delete items;
      items = old_items;
      free (buf);
      return errbuf;
    }

  if (nsubtypes == 1)
    {
      subtypes[0] = BaseMetric::STATIC;
      (void) add_matching_dmetrics (base_items, NTXT ("name"), subtypes, 1, VAL_VALUE, true);
    }

  // replace the old list of items, with the new set
  if (old_items)
    {
      old_items->destroy ();
      delete old_items;
    }
  set_fallback_sort ();
  free (buf);
  delete base_items;
  return NULL;
}

void
MetricList::set_fallback_sort ()
{
  // sort by first visible of the appropriate flavor
  char *sortcmd = NULL;
  switch (mtype)
    {
    case MET_NORMAL:
    case MET_COMMON:
      sortcmd = NTXT ("ei.any:name");
      break;
    case MET_SRCDIS:
      sortcmd = NTXT ("i.any:name");
      break;
    case MET_CALL:
    case MET_CALL_AGR:
      sortcmd = NTXT ("a.any:name");
      break;
    case MET_DATA:
      sortcmd = NTXT ("d.any:name");
      break;
    case MET_INDX:
      sortcmd = NTXT ("e.any:name");
      break;
    case MET_IO:
      sortcmd = NTXT ("e.any:name");
      break;
    case MET_HEAP:
      sortcmd = NTXT ("e.any:name");
      break;
    }
  if (NULL != sortcmd)
    (void) set_sort (sortcmd, true);
}

void
MetricList::set_metrics (MetricList *mlist)
{
  // verify that the type is appropriate for the call
  if (mtype == MET_NORMAL || mtype == MET_COMMON
      || (mlist->mtype != MET_NORMAL && mlist->mtype != MET_COMMON))
    abort ();

  Vector<Metric*> *mlist_items = mlist->get_items ();
  items->destroy ();
  items->reset ();

  int sort_ind = mlist->get_sort_ref_index ();
  for (int i = 0, mlist_sz = mlist_items->size (); i < mlist_sz; i++)
    {
      Metric *mtr = mlist_items->fetch (i);
      if (!mtr->is_any_visible ())
        continue;

      //  Add a new Metric with probably a new sub_type to this->items:
      //    for MET_CALL and MET_CALL_AGR the matching entry to an e. or i. is itself
      //    for MET_DATA, the matching entry to an e. or i. is the d. metric
      //    for MET_INDX, the matching entry to an e. or i. is the e. metric
      //    for MET_IO, the matching entry to an e. or i. is the e. metric
      //    for MET_HEAP, the matching entry to an e. or i. is the e. metric
      //    Save static entries (SIZES and ADDRESS) only for MET_NORMAL, MET_CALL, MET_CALL_AGR, MET_SRCDIS
      switch (mtr->get_type ())
        {
        case BaseMetric::SIZES:
        case BaseMetric::ADDRESS:
          switch (mtype)
            {
            case MET_NORMAL:
            case MET_COMMON:
            case MET_CALL:
            case MET_CALL_AGR:
            case MET_SRCDIS:
              break;
            default:
              continue;
            }
          break;
        default:
          break;
        }

      BaseMetric::SubType st = mtr->get_subtype ();
      if (st != BaseMetric::STATIC)
        {
          if (mtype == MET_CALL || mtype == MET_CALL_AGR)
            {
              if ((mtr->get_flavors () & BaseMetric::ATTRIBUTED) == 0)
                continue;
              st = BaseMetric::ATTRIBUTED;
            }
          else if (mtype == MET_DATA)
            {
              if ((mtr->get_flavors () & BaseMetric::DATASPACE) == 0)
                continue;
              st = BaseMetric::DATASPACE;
            }
          else if (mtype == MET_INDX)
            {
              if ((mtr->get_flavors () & BaseMetric::EXCLUSIVE) == 0)
                continue;
              st = BaseMetric::EXCLUSIVE;
            }
          else if (mtype == MET_IO)
            {
              if (mtr->get_packet_type () != DATA_IOTRACE ||
                  (mtr->get_flavors () & BaseMetric::EXCLUSIVE) == 0)
                continue;
              st = BaseMetric::EXCLUSIVE;
            }
          else if (mtype == MET_HEAP)
            {
              if (mtr->get_packet_type () != DATA_HEAP ||
                  (mtr->get_flavors () & BaseMetric::EXCLUSIVE) == 0)
                continue;
              st = BaseMetric::EXCLUSIVE;
            }
          else if (mtype == MET_SRCDIS)
            {
              if ((mtr->get_flavors () & BaseMetric::INCLUSIVE) == 0)
                continue;
              st = BaseMetric::INCLUSIVE;
            }
        }

      bool found = false;
      for (int i1 = 0, items_sz = items->size (); i1 < items_sz; i1++)
        {
          Metric *m1 = items->fetch (i1);
          if (mtr->get_id () == m1->get_id () && st == m1->get_subtype ())
            {
              if (sort_ind == i)
                sort_ind = i1;
              found = true;
              break;
            }
        }
      if (found)
        continue;
      Metric *m = new Metric (*mtr);
      m->set_subtype (st);
      m->set_raw_visbits (mtr->get_visbits ());
      if (sort_ind == i)
        sort_ind = items->size ();
      items->append (m);
    }
  if (sort_ind >= items->size ())
    sort_ind = 0;
  if (mtype == MET_IO)
    sort_ind = 0;
  if (mtype == MET_HEAP)
    sort_ind = 0;
  sort_ref_index = sort_ind;

}


// set_sort:
//      Sets the sort for the metric list to the first metric
//      in mspec that is present; if fromRcFile is false, then
//      only one metric may be specified.  The requested sort
//      metric must be visible, or it won't  be in the metric list

char *
MetricList::set_sort (const char *mspec, bool fromRcFile)
{
  char *mcmd;
  BaseMetric::SubType subtypes[10];
  int nsubtypes;
  int vis;
  bool parseOK = false;
  bool reverse = false;
  char buf[BUFSIZ];
  char *list = buf;
  char *mname;

  // copy the input specification
  snprintf (buf, sizeof (buf), NTXT ("%s"), mspec);
  char *listp = list;
  if (*listp == '-')
    {
      // reverse sort specified
      reverse = true;
      listp++;
    }

  // search for metric items from parsing the string
  while ((mcmd = strtok (listp, NTXT (":"))) != NULL)
    {
      listp = NULL; // let strtok keep track

      // parse the single metric_spec, based on the type of list being constructed, into:
      //        a vector of SubTypes (any of [iead] or STATIC)
      //        a integer mask for the visibility bits
      //        and the string name of the base metric
      mname = parse_metric_spec (mcmd, subtypes, &nsubtypes, &vis, &parseOK);
      if (!parseOK)
        {
          // error parsing the metric specification
          // not from an rc file, it's an error
          if (!fromRcFile)
            return (mname);
          continue;
        }
      if (VAL_IS_HIDDEN (vis))
        continue;

      // loop over subtypes requested to find metric
      // add a metric of that subtype, with specified vis.bits
      for (int i = 0; i < nsubtypes; i++)
        {
          // make sure the subtype is acceptable
          if ((mtype == MET_CALL || mtype == MET_CALL_AGR)
              && subtypes[i] != BaseMetric::ATTRIBUTED
              && subtypes[i] != BaseMetric::STATIC)
              return dbe_sprintf (GTXT ("Inclusive, Exclusive, or Data metrics cannot be specified for caller-callee sort: %s\n"),
                                  mcmd);
          if (mtype == MET_DATA && subtypes[i] != BaseMetric::DATASPACE
              && subtypes[i] != BaseMetric::STATIC)
              return dbe_sprintf (GTXT ("Inclusive, Exclusive, or Attributed metrics cannot be specified for data-derived sort: %s\n"),
                                  mcmd);
          if (mtype == MET_INDX && subtypes[i] != BaseMetric::EXCLUSIVE
                                   && subtypes[i] != BaseMetric::STATIC)
            return dbe_sprintf (GTXT ("Inclusive, Data or Attributed metrics cannot be specified for index sort: %s\n"),
                                mcmd);
          if ((mtype == MET_NORMAL || mtype == MET_COMMON
               || mtype == MET_SRCDIS)
              && (subtypes[i] == BaseMetric::DATASPACE
                  || subtypes[i] == BaseMetric::ATTRIBUTED))
            return dbe_sprintf (GTXT ("Data or Attributed metrics cannot be specified for sort: %s\n"), mcmd);
          if (set_sort_metric (mname, subtypes[i], reverse))
            return NULL;
        }
      // continue looking at entries
    }

  // not found on the list at all
  switch (mtype)
    {
    case MET_NORMAL:
    case MET_COMMON:
    case MET_SRCDIS:
      return dbe_sprintf (GTXT ("Invalid sort specification: %s\n"), mspec);
    case MET_CALL:
    case MET_CALL_AGR:
      return dbe_sprintf (GTXT ("Invalid caller-callee sort specification: %s\n"),
                          mspec);
    case MET_DATA:
      return dbe_sprintf (GTXT ("Invalid data-derived sort specification: %s\n"),
                          mspec);
    case MET_INDX:
      return dbe_sprintf (GTXT ("Invalid index sort specification: %s\n"),
                          mspec);
    case MET_IO:
      return dbe_sprintf (GTXT ("Invalid I/O sort specification: %s\n"), mspec);
    case MET_HEAP:
      return dbe_sprintf (GTXT ("Invalid heap sort specification: %s\n"),
                          mspec);
    }
  return NULL;
}

// set_sort to the metric with the given visible index

void
MetricList::set_sort (int visindex, bool reverse)
{
  Metric *mitem;
  if (visindex < items->size ())
    {
      mitem = items->fetch (visindex);
      if (mitem->is_any_visible ())
        {
          sort_ref_index = visindex;
          sort_reverse = reverse;
          return;
        }
    }
  set_fallback_sort ();
}

bool
MetricList::set_sort_metric (char *mname, BaseMetric::SubType mst, bool reverse)
{
  bool any = false, hwc = false, bit = false;

  // check keywords 'any', 'all', 'bit' and 'hwc'
  if (!strcasecmp (mname, Command::ANY_CMD))
    any = true;
  else if (!strcasecmp (mname, Command::ALL_CMD))
    any = true;
  else if (!strcasecmp (mname, Command::HWC_CMD))
    hwc = true;
  else if (!strcasecmp (mname, Command::BIT_CMD))
    bit = true;

  for (int i = 0, items_sz = items->size (); i < items_sz; i++)
    {
      Metric *m = items->fetch (i);
      if (mst == m->get_subtype ()
          && (any || (hwc && m->get_type () == BaseMetric::HWCNTR)
              || (bit && m->get_cmd ()
                  && strncmp (Command::BIT_CMD, m->get_cmd (),
                              strlen (Command::BIT_CMD)) == 0)
              || dbe_strcmp (mname, m->get_cmd ()) == 0))
        {
          sort_ref_index = i;
          sort_reverse = reverse;
          return true;
        }
    }
  return false;
}

// Print to a file of a list of metrics from a supplied vector
//      Debug flag = 1, prints the short name and address of the list
//      Debug flag = 2, prints the details of the list
void
MetricList::print_metric_list (FILE *dis_file, char *leader, int debug)
{
  Metric *item;
  int index;
  char fmt_name[64];
  fprintf (dis_file, NTXT ("%s"), leader);
  if (items == NULL)
    {
      fprintf (dis_file, GTXT ("NULL metric list can not be printed; aborting"));
      abort ();
    }

  if (items->size () == 0)
    {
      fprintf (dis_file, GTXT ("metric list is empty; aborting\n"));
      abort ();
    }

  // if debugging, print list address and string, and sort name
  if (debug != 0)
    {
      char *s = get_metrics ();
      fprintf (dis_file, "\tmetriclist at 0x%lx: %s, %lld metrics; sort by %s\n",
               (unsigned long) this, s, (long long) items->size (),
               get_sort_name ());
      free (s);
      if (debug == 1)
        return;
    }

  // Find the longest metric name & command
  size_t max_len = 0;
  size_t max_len2 = 0;

  Vec_loop (Metric*, items, index, item)
  {
    // get the name
    char *mn = item->get_name ();
    size_t len = strlen (mn);
    if (max_len < len)
      max_len = len;

    mn = item->get_mcmd (true);
    len = strlen (mn);
    if (max_len2 < len)
      max_len2 = len;
    free (mn);

  }
  if (debug == 2)
    snprintf (fmt_name, sizeof (fmt_name), "%%%ds: %%-%ds", (int) max_len,
              (int) max_len2);
  else
    snprintf (fmt_name, sizeof (fmt_name), "%%%ds: %%s", (int) max_len);

  Vec_loop (Metric*, items, index, item)
  {
    char *mcmd = item->get_mcmd (true);
    fprintf (dis_file, fmt_name, item->get_name (), mcmd);
    free (mcmd);
    if (debug == 2)
      fprintf (dis_file, "\t[st %2d, VT %d, vis = %4s, T=%d, sort = %c]",
               item->get_subtype (), item->get_vtype (),
               item->get_vis_str (), item->is_time_val (),
               sort_ref_index == index ? 'Y' : 'N');
    fputc ('\n', dis_file);
  }

  fputc ('\n', dis_file);
  fflush (dis_file);
}

// Return a string formatted from a vector of metrics
//      string is in the form suitable for a "metrics <string>" command
char *
MetricList::get_metrics ()
{
  Metric *item;
  int index;
  StringBuilder sb;
  Vec_loop (Metric*, items, index, item)
  {
    if (sb.length () != 0)
      sb.append (':');
    char *mcmd = item->get_mcmd (false);
    sb.append (mcmd);
    free (mcmd);
  }
  return sb.toString ();
}

int
MetricList::get_listorder (Metric *mtr)
{
  for (int i = 0, items_sz = items->size (); i < items_sz; i++)
    {
      Metric *m = items->fetch (i);
      if (m->get_subtype () == mtr->get_subtype ()
          && m->get_id () == mtr->get_id ())
        return i;
    }
  return -1;
}

int
MetricList::get_listorder (char *cmd, BaseMetric::SubType st, const char *expr)
{
  for (long i = 0, items_sz = items->size (); i < items_sz; i++)
    {
      Metric *m = items->fetch (i);
      if (m->get_subtype () == st && dbe_strcmp (m->get_cmd (), cmd) == 0
          && dbe_strcmp (m->get_expr_spec (), expr) == 0)
        return (int) i;
    }
  return -1;
}

Metric *
MetricList::find_metric_by_name (char *cmd)
{
  for (long i = 0, items_sz = items->size (); i < items_sz; i++)
    {
      Metric *m = items->fetch (i);
      if (dbe_strcmp (m->get_cmd (), cmd) == 0)
        return m;
    }
  return NULL;
}

//  find a metric by name and subtype
Metric *
MetricList::find_metric (char *cmd, BaseMetric::SubType st)
{
  int i = get_listorder (cmd, st);
  if (i < 0)
    return NULL;
  return items->fetch (i);
}

//  Get the sort metric from a list; forces sort by first if not set
Metric *
MetricList::get_sort_metric ()
{
  int i = get_sort_ref_index ();
  return i >= 0 ? items->fetch (i) : NULL;
}

char *
MetricList::get_sort_name ()
{
  Metric *item = get_sort_metric ();
  if (item == NULL)
    return dbe_strdup (NTXT (""));
  char *n = item->get_name ();
  return sort_reverse ? dbe_sprintf ("-%s", n) : dbe_strdup (n);
}

char *
MetricList::get_sort_cmd ()
{
  char *buf;
  Metric *item = get_sort_metric ();
  if (item == NULL)
    return dbe_strdup (NTXT (""));
  char *n = item->get_mcmd (false);
  if (sort_reverse)
    {
      buf = dbe_sprintf (NTXT ("-%s"), n);
      free (n);
    }
  else
    buf = n;
  return buf;
}

Metric *
MetricList::append (BaseMetric *bm, BaseMetric::SubType st, int visbits)
{
  for (long i = 0, sz = items->size (); i < sz; i++)
    {
      Metric *m = items->get (i);
      if (m->get_id () == bm->get_id () && m->get_subtype () == st)
        return NULL;
    }
  Metric *met = new Metric (bm, st);
  met->set_dmetrics_visbits (visbits);
  items->append (met);
  return met;
}

int
MetricList::add_matching_dmetrics (Vector<BaseMetric*> *base_items,
                                   char *mcmd, BaseMetric::SubType *_subtypes,
                                   int nsubtypes, int dmetrics_visbits,
                                   bool fromRcFile)
{
  bool any = false, hwc = false, bit = false;
  int got_metric = 1;

  // check keywords 'any', 'all', 'bit', and 'hwc'
  if (!strcasecmp (mcmd, Command::ANY_CMD))
    any = true;
  else if (!strcasecmp (mcmd, Command::ALL_CMD))
    any = true;
  else if (!strcasecmp (mcmd, Command::HWC_CMD))
    hwc = true;
  else if (!strcasecmp (mcmd, Command::BIT_CMD))
    bit = true;

  BaseMetric::SubType *subtypes = _subtypes;
  BaseMetric::SubType all_subtypes[2] =
    { BaseMetric::EXCLUSIVE, BaseMetric::INCLUSIVE };

  if (nsubtypes == 0 || (nsubtypes == 1 && subtypes[0] == BaseMetric::STATIC))
    {
      // user did not specify ei; treat as wildcard and supply both.
      subtypes = all_subtypes;
      nsubtypes = 2;
    }

  // scan the metrics to find all matches
  for (int i = 0, base_sz = base_items->size (); i < base_sz; i++)
    {
      BaseMetric *item = base_items->fetch (i);
      if (!(any || (hwc && item->get_type () == BaseMetric::HWCNTR)
            || (bit && item->get_cmd ()
                && strncmp (item->get_cmd (), Command::BIT_CMD,
                            strlen (Command::BIT_CMD)) == 0)
            || dbe_strcmp (item->get_cmd (), mcmd) == 0))
        continue;
      if (item->is_internal ())
        continue;
      if (item->get_flavors () & BaseMetric::STATIC)
        {
          got_metric = 0;
          int vis = item->get_type () != BaseMetric::ONAME ?
                  dmetrics_visbits : VAL_VALUE;
          if (append (item, BaseMetric::STATIC, vis) == NULL && !fromRcFile)
            return 2;
          continue;
        }

      // special case for omp metrics: make visible only if
      // omp data has been collected
      if (!dbeSession->is_omp_available ()
          && (strcasecmp (mcmd, "ompwork") == 0
              || strcasecmp (mcmd, "ompwait") == 0))
          continue;

      for (int j = 0; j < nsubtypes; j++)
        {
          if (append (item, subtypes[j], dmetrics_visbits) == NULL
              && !fromRcFile)
            return 2;
        }
      got_metric = 0;
      if (!(any || hwc || bit))
        break;
    }
  return got_metric;
}

// parse a single metric specification, to give:
//      a vector of subtypes, and a count of the number of them
//      an integer visibility
//      return the string for the metric name

char *
MetricList::parse_metric_spec (char *mcmd, BaseMetric::SubType *subtypes,
                               int *nsubtypes, int *dmetrics_visb, bool *isOK)
{
  size_t len_vtype;
  int index;
  int vis;
  bool got_e, got_i, got_a, got_d;
  char *str = mcmd;
  char *str2;

  *isOK = true;

  // For dynamic metrics, each keyword is of the form  <flavor><visibility><metric-name>
  // For static metrics, each keyword is of the form [<visibility>]<metric-name>
  // <flavor> can be either "i" for inclusive or "e" for exclusive
  // <visibility> can be any combination of "." (to show the metric as a time),
  //    "%" (to show it as a percentage), "+" (to show it as a count), and "!" (turn off the metric)

  // find subtype
  index = 0;
  size_t len_subtype = strspn (str, NTXT ("eiad"));
  str2 = str + len_subtype;

  // find vis
  if (len_subtype == 0)
    {
      // only a . or ! is possible if no subtypes
      len_vtype = strspn (str2, NTXT (".!"));
      vis = VAL_VALUE;
    }
  else
    {
      len_vtype = strspn (str2, NTXT (".+%!"));
      vis = VAL_NA;
    }

  // if no visibility bits, there can't be a subtype
  if (len_vtype == 0)
    len_subtype = 0;

  if (len_subtype == 0)
    {
      // must be a static metric
      subtypes[index++] = BaseMetric::STATIC;
      vis = VAL_VALUE;
    }
  else
    {
      // figure out which subtypes are specified
      got_e = got_i = got_a = got_d = false;
      for (size_t i = 0; i < len_subtype; i++)
        {
          str += len_subtype;
          if (mcmd[i] == 'e')
            { // exclusive
              if (mtype == MET_DATA)
                {
                  *isOK = false;
                  return dbe_sprintf (GTXT ("Invalid metric specification: %s inapplicable for data metrics\n"),
                                      mcmd);
                }
              if (!got_e)
                {
                  got_e = true;
                  subtypes[index++] = BaseMetric::EXCLUSIVE;
                }
            }
          else if (mcmd[i] == 'i')
            { // inclusive
              if (mtype == MET_DATA)
                {
                  *isOK = false;
                  return dbe_sprintf (GTXT ("Invalid metric specification: %s inapplicable for data metrics\n"),
                                      mcmd);
                }
              if (mtype == MET_INDX)
                {
                  *isOK = false;
                  return dbe_sprintf (GTXT ("Invalid metric specification: %s inapplicable for index metrics\n"),
                                      mcmd);
                }
              if (!got_i)
                {
                  got_i = true;
                  subtypes[index++] = BaseMetric::INCLUSIVE;
                }
            }
          else if (mcmd[i] == 'a')
            { // attributed
              if (mtype != MET_CALL && mtype != MET_CALL_AGR)
                {
                  *isOK = false;
                  return dbe_sprintf (GTXT ("Invalid metric specification: %s applicable for caller-callee metrics only\n"),
                                      mcmd);
                }
              if (!got_a)
                {
                  got_a = true;
                  subtypes[index++] = BaseMetric::ATTRIBUTED;
                }
            }
          else if (mcmd[i] == 'd')
            { // data-space
              if (mtype != MET_DATA)
                {
                  *isOK = false;
                  return dbe_sprintf (GTXT ("Invalid metric specification: %s applicable for data-derived metrics only\n"),
                                      mcmd);
                }
              if (!got_d)
                {
                  got_d = true;
                  subtypes[index++] = BaseMetric::DATASPACE;
                }
            }
        }
    }
  *nsubtypes = index;

  // now determine the visiblity bits
  if (len_vtype > 0)
    {
      for (size_t i = 0; i < len_vtype; i++)
        {
          if (str2[i] == '+')
            vis = (vis | VAL_VALUE);
          else if (str2[i] == '.')
            vis = (vis | VAL_TIMEVAL);
          else if (str2[i] == '%')
            vis = (vis | VAL_PERCENT);
          else if (str2[i] == '!')
            vis = (vis | VAL_HIDE_ALL);
        }
    }
  *dmetrics_visb = vis;
  return mcmd + len_subtype + len_vtype;
}