gprofng/src/BaseMetricTreeNode.cc - binutils-gdb - Git at Google

 /* 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 <stdio.h>
 #include <strings.h>
 #include <limits.h>
 #include <sys/param.h>

 #include "hwcentry.h"
 #include "DbeSession.h"
 #include "Experiment.h"
 #include "Expression.h"
 #include "Metric.h"
 #include "Table.h"
 #include "i18n.h"
 #include "debug.h"

 BaseMetricTreeNode::BaseMetricTreeNode ()
 {
   init_vars ();
   build_basic_tree ();
 }

 BaseMetricTreeNode::BaseMetricTreeNode (BaseMetric *item)
 {
   init_vars ();
   bm = item;
   name = dbe_strdup (bm->get_cmd ());
   uname = dbe_strdup (bm->get_username ());
   unit = NULL; //YXXX populate from base_metric (requires updating base_metric)
   unit_uname = NULL;
 }

 BaseMetricTreeNode::BaseMetricTreeNode (const char *_name, const char *_uname,
 				    const char *_unit, const char *_unit_uname)
 {
   init_vars ();
   name = dbe_strdup (_name);
   uname = dbe_strdup (_uname);
   unit = dbe_strdup (_unit);
   unit_uname = dbe_strdup (_unit_uname);
 }

 void
 BaseMetricTreeNode::init_vars ()
 {
   name = NULL;
   uname = NULL;
   unit = NULL;
   unit_uname = NULL;
   root = this;
   parent = NULL;
   children = new Vector<BaseMetricTreeNode*>;
   isCompositeMetric = false;
   bm = NULL;
   registered = false;
   num_registered_descendents = 0;
 }

 BaseMetricTreeNode::~BaseMetricTreeNode ()
 {
   children->destroy ();
   delete children;
   free (name);
   free (uname);
   free (unit);
   free (unit_uname);
 }

 BaseMetricTreeNode *
 BaseMetricTreeNode::register_metric (BaseMetric *item)
 {
   BaseMetricTreeNode *found = root->find (item->get_cmd ());
   if (!found)
     {
       switch (item->get_type ())
 	{
 	case BaseMetric::CP_TOTAL:
 	  found = root->find (L_CP_TOTAL);
 	  break;
 	case BaseMetric::CP_TOTAL_CPU:
 	  found = root->find (L_CP_TOTAL_CPU);
 	  break;
 	}
       if (found && found->bm == NULL)
 	found->bm = item;
     }
   if (!found)
     {
       switch (item->get_type ())
 	{
 	case BaseMetric::HEAP_ALLOC_BYTES:
 	case BaseMetric::HEAP_ALLOC_CNT:
 	case BaseMetric::HEAP_LEAK_BYTES:
 	case BaseMetric::HEAP_LEAK_CNT:
 	  found = root->find (get_prof_data_type_name (DATA_HEAP));
 	  break;
 	case BaseMetric::CP_KERNEL_CPU:
 	case BaseMetric::CP_TOTAL:
 	  found = root->find (get_prof_data_type_name (DATA_CLOCK));
 	  break;
 	case BaseMetric::CP_LMS_DFAULT:
 	case BaseMetric::CP_LMS_TFAULT:
 	case BaseMetric::CP_LMS_KFAULT:
 	case BaseMetric::CP_LMS_STOPPED:
 	case BaseMetric::CP_LMS_WAIT_CPU:
 	case BaseMetric::CP_LMS_SLEEP:
 	case BaseMetric::CP_LMS_USER_LOCK:
 	case BaseMetric::CP_TOTAL_CPU:
 	  found = root->find (L_CP_TOTAL);
 	  break;
 	case BaseMetric::CP_LMS_USER:
 	case BaseMetric::CP_LMS_SYSTEM:
 	case BaseMetric::CP_LMS_TRAP:
 	  found = root->find (L_CP_TOTAL_CPU);
 	  break;
 	case BaseMetric::HWCNTR:
 	  found = root->find ((item->get_flavors () & BaseMetric::DATASPACE) != 0 ?
 			      L2_HWC_DSPACE : L2_HWC_GENERAL);
 	  break;
 	case BaseMetric::SYNC_WAIT_TIME:
 	case BaseMetric::SYNC_WAIT_COUNT:
 	  found = root->find (get_prof_data_type_name (DATA_SYNCH));
 	  break;
 	case BaseMetric::OMP_WORK:
 	case BaseMetric::OMP_WAIT:
 	case BaseMetric::OMP_OVHD:
 	  found = root->find (get_prof_data_type_name (DATA_OMP));
 	  break;
 	case BaseMetric::IO_READ_TIME:
 	case BaseMetric::IO_READ_BYTES:
 	case BaseMetric::IO_READ_CNT:
 	case BaseMetric::IO_WRITE_TIME:
 	case BaseMetric::IO_WRITE_BYTES:
 	case BaseMetric::IO_WRITE_CNT:
 	case BaseMetric::IO_OTHER_TIME:
 	case BaseMetric::IO_OTHER_CNT:
 	case BaseMetric::IO_ERROR_TIME:
 	case BaseMetric::IO_ERROR_CNT:
 	  found = root->find (get_prof_data_type_name (DATA_IOTRACE));
 	  break;
 	case BaseMetric::ONAME:
 	case BaseMetric::SIZES:
 	case BaseMetric::ADDRESS:
 	  found = root->find (L1_STATIC);
 	  break;
 	default:
 	  found = root->find (L1_OTHER);
 	  break;
 	}
       assert (found != NULL);
       switch (item->get_type ())
 	{
 	case BaseMetric::CP_TOTAL:
 	case BaseMetric::CP_TOTAL_CPU:
 	  found->isCompositeMetric = true;
 	  break;
 	}
       found = found->add_child (item);
     }
   register_node (found);
   return found;
 }

 void
 BaseMetricTreeNode::register_node (BaseMetricTreeNode *node)
 {
   if (!node->registered)
     {
       node->registered = true;
       BaseMetricTreeNode *tmp = node->parent;
       while (tmp)
 	{
 	  tmp->num_registered_descendents++;
 	  tmp = tmp->parent;
 	}
     }
 }

 BaseMetricTreeNode *
 BaseMetricTreeNode::find (const char *_name)
 {
   BaseMetricTreeNode *found = NULL;
   if (dbe_strcmp (get_name (), _name) == 0)
     return this;
   if (bm && dbe_strcmp (bm->get_cmd (), _name) == 0)
     return this;
   BaseMetricTreeNode *child;
   int index;

   Vec_loop (BaseMetricTreeNode*, children, index, child)
   {
     found = child->find (_name);
     if (found)
       return found;
   }
   return NULL;
 }

 static void
 int_get_registered_descendents (BaseMetricTreeNode* curr,
 			  Vector<BaseMetricTreeNode*> *dest, bool nearest_only)
 {
   if (!curr)
     return;
   if (curr->is_registered ())
     {
       dest->append (curr);
       if (nearest_only)
 	return; // soon as we hit a live node, stop following branch
     }
   int index;
   BaseMetricTreeNode *child;

   Vec_loop (BaseMetricTreeNode*, curr->get_children (), index, child)
   {
     int_get_registered_descendents (child, dest, nearest_only);
   }
 }

 void
 BaseMetricTreeNode::get_nearest_registered_descendents (Vector<BaseMetricTreeNode*> *dest)
 {
   if (!dest || dest->size () != 0)
     abort ();
   bool nearest_only = true;
   int_get_registered_descendents (this, dest, nearest_only);
 }

 void
 BaseMetricTreeNode::get_all_registered_descendents (Vector<BaseMetricTreeNode*> *dest)
 {
   if (!dest || dest->size () != 0)
     abort ();
   bool nearest_only = false;
   int_get_registered_descendents (this, dest, nearest_only);
 }

 char *
 BaseMetricTreeNode::get_description ()
 {
   if (bm)
     {
       Hwcentry* hw_ctr = bm->get_hw_ctr ();
       if (hw_ctr)
 	return hw_ctr->short_desc;
     }
   return NULL;
 }

 void
 BaseMetricTreeNode::build_basic_tree ()
 {
 #define TREE_INSERT_DATA_TYPE(t) add_child(get_prof_data_type_name (t), get_prof_data_type_uname (t))
   BaseMetricTreeNode *level1, *level2;
   // register L1_DURATION here because it has a value but is not a true metric
   register_node (add_child (L1_DURATION, L1_DURATION_UNAME, UNIT_SECONDS,
 			    UNIT_SECONDS_UNAME));
   register_node (add_child (L1_GCDURATION, L1_GCDURATION_UNAME, UNIT_SECONDS,
 			    UNIT_SECONDS_UNAME));
   TREE_INSERT_DATA_TYPE (DATA_HEAP);
   level1 = TREE_INSERT_DATA_TYPE (DATA_CLOCK);
   level1 = level1->add_child (L_CP_TOTAL, GTXT ("XXX Total Thread Time"));
   level1->isCompositeMetric = true;
   level2 = level1->add_child (L_CP_TOTAL_CPU, GTXT ("XXX Total CPU Time"));
   level2->isCompositeMetric = true;

   add_child (L1_OTHER, L1_OTHER_UNAME);
   level1 = TREE_INSERT_DATA_TYPE (DATA_HWC);
   level1->add_child (L2_HWC_DSPACE, L2_HWC_DSPACE_UNAME);
   level1->add_child (L2_HWC_GENERAL, L2_HWC_GENERAL_UNAME);
   TREE_INSERT_DATA_TYPE (DATA_SYNCH);
   TREE_INSERT_DATA_TYPE (DATA_OMP);
   TREE_INSERT_DATA_TYPE (DATA_IOTRACE);
   add_child (L1_STATIC, L1_STATIC_UNAME);
 }

 BaseMetricTreeNode *
 BaseMetricTreeNode::add_child (BaseMetric *item)
 {
   return add_child (new BaseMetricTreeNode (item));
 }

 BaseMetricTreeNode *
 BaseMetricTreeNode::add_child (const char * _name, const char *_uname,
 			       const char * _unit, const char * _unit_uname)
 {
   return add_child (new BaseMetricTreeNode (_name, _uname, _unit, _unit_uname));
 }

 BaseMetricTreeNode *
 BaseMetricTreeNode::add_child (BaseMetricTreeNode *new_node)
 {
   new_node->parent = this;
   new_node->root = root;
   children->append (new_node);
   return new_node;
 }

 char *
 BaseMetricTreeNode::dump ()
 {
   int len = 4;
   char *s = bm ? bm->dump () : dbe_strdup ("<no base metric>");
   char *msg = dbe_sprintf ("%s\n%*c %*c unit='%s' unit_uname='%s' uname='%s' name='%s'\n",
 			   STR (s), len, ' ', len, ' ',
 			   STR (get_unit_uname ()), STR (get_unit ()),
 			   STR (get_user_name ()), STR (get_name ()));
   free (s);
   return msg;
 }
	/* 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 <stdio.h>
	#include <strings.h>
	#include <limits.h>
	#include <sys/param.h>

	#include "hwcentry.h"
	#include "DbeSession.h"
	#include "Experiment.h"
	#include "Expression.h"
	#include "Metric.h"
	#include "Table.h"
	#include "i18n.h"
	#include "debug.h"

	BaseMetricTreeNode::BaseMetricTreeNode ()
	{
	init_vars ();
	build_basic_tree ();
	}

	BaseMetricTreeNode::BaseMetricTreeNode (BaseMetric *item)
	{
	init_vars ();
	bm = item;
	name = dbe_strdup (bm->get_cmd ());
	uname = dbe_strdup (bm->get_username ());
	unit = NULL; //YXXX populate from base_metric (requires updating base_metric)
	unit_uname = NULL;
	}

	BaseMetricTreeNode::BaseMetricTreeNode (const char _name, const char _uname,
	const char _unit, const char _unit_uname)
	{
	init_vars ();
	name = dbe_strdup (_name);
	uname = dbe_strdup (_uname);
	unit = dbe_strdup (_unit);
	unit_uname = dbe_strdup (_unit_uname);
	}

	void
	BaseMetricTreeNode::init_vars ()
	{
	name = NULL;
	uname = NULL;
	unit = NULL;
	unit_uname = NULL;
	root = this;
	parent = NULL;
	children = new Vector<BaseMetricTreeNode*>;
	isCompositeMetric = false;
	bm = NULL;
	registered = false;
	num_registered_descendents = 0;
	}

	BaseMetricTreeNode::~BaseMetricTreeNode ()
	{
	children->destroy ();
	delete children;
	free (name);
	free (uname);
	free (unit);
	free (unit_uname);
	}

	BaseMetricTreeNode *
	BaseMetricTreeNode::register_metric (BaseMetric *item)
	{
	BaseMetricTreeNode *found = root->find (item->get_cmd ());
	if (!found)
	{
	switch (item->get_type ())
	{
	case BaseMetric::CP_TOTAL:
	found = root->find (L_CP_TOTAL);
	break;
	case BaseMetric::CP_TOTAL_CPU:
	found = root->find (L_CP_TOTAL_CPU);
	break;
	}
	if (found && found->bm == NULL)
	found->bm = item;
	}
	if (!found)
	{
	switch (item->get_type ())
	{
	case BaseMetric::HEAP_ALLOC_BYTES:
	case BaseMetric::HEAP_ALLOC_CNT:
	case BaseMetric::HEAP_LEAK_BYTES:
	case BaseMetric::HEAP_LEAK_CNT:
	found = root->find (get_prof_data_type_name (DATA_HEAP));
	break;
	case BaseMetric::CP_KERNEL_CPU:
	case BaseMetric::CP_TOTAL:
	found = root->find (get_prof_data_type_name (DATA_CLOCK));
	break;
	case BaseMetric::CP_LMS_DFAULT:
	case BaseMetric::CP_LMS_TFAULT:
	case BaseMetric::CP_LMS_KFAULT:
	case BaseMetric::CP_LMS_STOPPED:
	case BaseMetric::CP_LMS_WAIT_CPU:
	case BaseMetric::CP_LMS_SLEEP:
	case BaseMetric::CP_LMS_USER_LOCK:
	case BaseMetric::CP_TOTAL_CPU:
	found = root->find (L_CP_TOTAL);
	break;
	case BaseMetric::CP_LMS_USER:
	case BaseMetric::CP_LMS_SYSTEM:
	case BaseMetric::CP_LMS_TRAP:
	found = root->find (L_CP_TOTAL_CPU);
	break;
	case BaseMetric::HWCNTR:
	found = root->find ((item->get_flavors () & BaseMetric::DATASPACE) != 0 ?
	L2_HWC_DSPACE : L2_HWC_GENERAL);
	break;
	case BaseMetric::SYNC_WAIT_TIME:
	case BaseMetric::SYNC_WAIT_COUNT:
	found = root->find (get_prof_data_type_name (DATA_SYNCH));
	break;
	case BaseMetric::OMP_WORK:
	case BaseMetric::OMP_WAIT:
	case BaseMetric::OMP_OVHD:
	found = root->find (get_prof_data_type_name (DATA_OMP));
	break;
	case BaseMetric::IO_READ_TIME:
	case BaseMetric::IO_READ_BYTES:
	case BaseMetric::IO_READ_CNT:
	case BaseMetric::IO_WRITE_TIME:
	case BaseMetric::IO_WRITE_BYTES:
	case BaseMetric::IO_WRITE_CNT:
	case BaseMetric::IO_OTHER_TIME:
	case BaseMetric::IO_OTHER_CNT:
	case BaseMetric::IO_ERROR_TIME:
	case BaseMetric::IO_ERROR_CNT:
	found = root->find (get_prof_data_type_name (DATA_IOTRACE));
	break;
	case BaseMetric::ONAME:
	case BaseMetric::SIZES:
	case BaseMetric::ADDRESS:
	found = root->find (L1_STATIC);
	break;
	default:
	found = root->find (L1_OTHER);
	break;
	}
	assert (found != NULL);
	switch (item->get_type ())
	{
	case BaseMetric::CP_TOTAL:
	case BaseMetric::CP_TOTAL_CPU:
	found->isCompositeMetric = true;
	break;
	}
	found = found->add_child (item);
	}
	register_node (found);
	return found;
	}

	void
	BaseMetricTreeNode::register_node (BaseMetricTreeNode *node)
	{
	if (!node->registered)
	{
	node->registered = true;
	BaseMetricTreeNode *tmp = node->parent;
	while (tmp)
	{
	tmp->num_registered_descendents++;
	tmp = tmp->parent;
	}
	}
	}

	BaseMetricTreeNode *
	BaseMetricTreeNode::find (const char *_name)
	{
	BaseMetricTreeNode *found = NULL;
	if (dbe_strcmp (get_name (), _name) == 0)
	return this;
	if (bm && dbe_strcmp (bm->get_cmd (), _name) == 0)
	return this;
	BaseMetricTreeNode *child;
	int index;

	Vec_loop (BaseMetricTreeNode*, children, index, child)
	{
	found = child->find (_name);
	if (found)
	return found;
	}
	return NULL;
	}

	static void
	int_get_registered_descendents (BaseMetricTreeNode* curr,
	Vector<BaseMetricTreeNode> dest, bool nearest_only)
	{
	if (!curr)
	return;
	if (curr->is_registered ())
	{
	dest->append (curr);
	if (nearest_only)
	return; // soon as we hit a live node, stop following branch
	}
	int index;
	BaseMetricTreeNode *child;

	Vec_loop (BaseMetricTreeNode*, curr->get_children (), index, child)
	{
	int_get_registered_descendents (child, dest, nearest_only);
	}
	}

	void
	BaseMetricTreeNode::get_nearest_registered_descendents (Vector<BaseMetricTreeNode> dest)
	{
	if (!dest \|\| dest->size () != 0)
	abort ();
	bool nearest_only = true;
	int_get_registered_descendents (this, dest, nearest_only);
	}

	void
	BaseMetricTreeNode::get_all_registered_descendents (Vector<BaseMetricTreeNode> dest)
	{
	if (!dest \|\| dest->size () != 0)
	abort ();
	bool nearest_only = false;
	int_get_registered_descendents (this, dest, nearest_only);
	}

	char *
	BaseMetricTreeNode::get_description ()
	{
	if (bm)
	{
	Hwcentry* hw_ctr = bm->get_hw_ctr ();
	if (hw_ctr)
	return hw_ctr->short_desc;
	}
	return NULL;
	}

	void
	BaseMetricTreeNode::build_basic_tree ()
	{
	#define TREE_INSERT_DATA_TYPE(t) add_child(get_prof_data_type_name (t), get_prof_data_type_uname (t))
	BaseMetricTreeNode level1, level2;
	// register L1_DURATION here because it has a value but is not a true metric
	register_node (add_child (L1_DURATION, L1_DURATION_UNAME, UNIT_SECONDS,
	UNIT_SECONDS_UNAME));
	register_node (add_child (L1_GCDURATION, L1_GCDURATION_UNAME, UNIT_SECONDS,
	UNIT_SECONDS_UNAME));
	TREE_INSERT_DATA_TYPE (DATA_HEAP);
	level1 = TREE_INSERT_DATA_TYPE (DATA_CLOCK);
	level1 = level1->add_child (L_CP_TOTAL, GTXT ("XXX Total Thread Time"));
	level1->isCompositeMetric = true;
	level2 = level1->add_child (L_CP_TOTAL_CPU, GTXT ("XXX Total CPU Time"));
	level2->isCompositeMetric = true;

	add_child (L1_OTHER, L1_OTHER_UNAME);
	level1 = TREE_INSERT_DATA_TYPE (DATA_HWC);
	level1->add_child (L2_HWC_DSPACE, L2_HWC_DSPACE_UNAME);
	level1->add_child (L2_HWC_GENERAL, L2_HWC_GENERAL_UNAME);
	TREE_INSERT_DATA_TYPE (DATA_SYNCH);
	TREE_INSERT_DATA_TYPE (DATA_OMP);
	TREE_INSERT_DATA_TYPE (DATA_IOTRACE);
	add_child (L1_STATIC, L1_STATIC_UNAME);
	}

	BaseMetricTreeNode *
	BaseMetricTreeNode::add_child (BaseMetric *item)
	{
	return add_child (new BaseMetricTreeNode (item));
	}

	BaseMetricTreeNode *
	BaseMetricTreeNode::add_child (const char * _name, const char *_uname,
	const char * _unit, const char * _unit_uname)
	{
	return add_child (new BaseMetricTreeNode (_name, _uname, _unit, _unit_uname));
	}

	BaseMetricTreeNode *
	BaseMetricTreeNode::add_child (BaseMetricTreeNode *new_node)
	{
	new_node->parent = this;
	new_node->root = root;
	children->append (new_node);
	return new_node;
	}

	char *
	BaseMetricTreeNode::dump ()
	{
	int len = 4;
	char *s = bm ? bm->dump () : dbe_strdup ("<no base metric>");
	char msg = dbe_sprintf ("%s\n%c %*c unit='%s' unit_uname='%s' uname='%s' name='%s'\n",
	STR (s), len, ' ', len, ' ',
	STR (get_unit_uname ()), STR (get_unit ()),
	STR (get_user_name ()), STR (get_name ()));
	free (s);
	return msg;
	}