[thirdparty/binutils-gdb.git] / gprofng / src / Exp_Layout.cc

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

   This file is part of GNU Binutils.

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

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

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

#include "config.h"
#include "CallStack.h"
#include "DbeSession.h"
#include "Exp_Layout.h"
#include "Experiment.h"
#include "Function.h"
#include "Table.h"
#include "dbe_types.h"
#include "util.h"

/*
 * PrUsage is a class which wraps access to the values of prusage
 * system structure. It was expanded to 64 bit entities in 2.7
 * (experiment version 6 & 7).
 */
PrUsage::PrUsage ()
{
  pr_tstamp = pr_create = pr_term = pr_rtime = (hrtime_t) 0;
  pr_utime = pr_stime = pr_ttime = pr_tftime = pr_dftime = (hrtime_t) 0;
  pr_kftime = pr_ltime = pr_slptime = pr_wtime = pr_stoptime = (hrtime_t) 0;

  pr_minf = pr_majf = pr_nswap = pr_inblk = pr_oublk = 0;
  pr_msnd = pr_mrcv = pr_sigs = pr_vctx = pr_ictx = pr_sysc = pr_ioch = 0;
}

/*
 * Resource usage.  /proc/<pid>/usage /proc/<pid>/lwp/<lwpid>/lwpusage
 */
struct timestruc_32
{ /* v8 timestruc_t */
  uint32_t tv_sec;              /* seconds */
  uint32_t tv_nsec;             /* and nanoseconds */
};

typedef struct ana_prusage
{
  id_t pr_lwpid;                /* lwp id.  0: process or defunct */
  int pr_count;                 /* number of contributing lwps */
  timestruc_32 pr_tstamp;       /* current time stamp */
  timestruc_32 pr_create;       /* process/lwp creation time stamp */
  timestruc_32 pr_term;         /* process/lwp termination time stamp */
  timestruc_32 pr_rtime;        /* total lwp real (elapsed) time */
  timestruc_32 pr_utime;        /* user level cpu time */
  timestruc_32 pr_stime;        /* system call cpu time */
  timestruc_32 pr_ttime;        /* other system trap cpu time */
  timestruc_32 pr_tftime;       /* text page fault sleep time */
  timestruc_32 pr_dftime;       /* data page fault sleep time */
  timestruc_32 pr_kftime;       /* kernel page fault sleep time */
  timestruc_32 pr_ltime;        /* user lock wait sleep time */
  timestruc_32 pr_slptime;      /* all other sleep time */
  timestruc_32 pr_wtime;        /* wait-cpu (latency) time */
  timestruc_32 pr_stoptime;     /* stopped time */
  timestruc_32 filltime[6];     /* filler for future expansion */
  uint32_t pr_minf;             /* minor page faults */
  uint32_t pr_majf;             /* major page faults */
  uint32_t pr_nswap;            /* swaps */
  uint32_t pr_inblk;            /* input blocks */
  uint32_t pr_oublk;            /* output blocks */
  uint32_t pr_msnd;             /* messages sent */
  uint32_t pr_mrcv;             /* messages received */
  uint32_t pr_sigs;             /* signals received */
  uint32_t pr_vctx;             /* voluntary context switches */
  uint32_t pr_ictx;             /* involuntary context switches */
  uint32_t pr_sysc;             /* system calls */
  uint32_t pr_ioch;             /* chars read and written */
  uint32_t filler[10];          /* filler for future expansion */
} raw_prusage_32;

uint64_t
PrUsage::bind32Size ()
{
  uint64_t bindSize = sizeof (raw_prusage_32);
  return bindSize;
}

#define timestruc2hr(x) ((hrtime_t)(x).tv_sec*NANOSEC + (hrtime_t)(x).tv_nsec)

PrUsage *
PrUsage::bind32 (void *p, bool need_swap_endian)
{
  if (p == NULL)
    return NULL;
  raw_prusage_32 pu, *tmp = (raw_prusage_32*) p;
  if (need_swap_endian)
    {
      pu = *tmp;
      tmp = &pu;
      SWAP_ENDIAN (pu.pr_tstamp.tv_sec);
      SWAP_ENDIAN (pu.pr_tstamp.tv_nsec);
      SWAP_ENDIAN (pu.pr_create.tv_sec);
      SWAP_ENDIAN (pu.pr_create.tv_nsec);
      SWAP_ENDIAN (pu.pr_term.tv_sec);
      SWAP_ENDIAN (pu.pr_term.tv_nsec);
      SWAP_ENDIAN (pu.pr_rtime.tv_sec);
      SWAP_ENDIAN (pu.pr_rtime.tv_nsec);
      SWAP_ENDIAN (pu.pr_utime.tv_sec);
      SWAP_ENDIAN (pu.pr_utime.tv_nsec);
      SWAP_ENDIAN (pu.pr_stime.tv_sec);
      SWAP_ENDIAN (pu.pr_stime.tv_nsec);
      SWAP_ENDIAN (pu.pr_ttime.tv_sec);
      SWAP_ENDIAN (pu.pr_ttime.tv_nsec);
      SWAP_ENDIAN (pu.pr_tftime.tv_sec);
      SWAP_ENDIAN (pu.pr_tftime.tv_nsec);
      SWAP_ENDIAN (pu.pr_dftime.tv_sec);
      SWAP_ENDIAN (pu.pr_dftime.tv_nsec);
      SWAP_ENDIAN (pu.pr_kftime.tv_sec);
      SWAP_ENDIAN (pu.pr_kftime.tv_nsec);
      SWAP_ENDIAN (pu.pr_ltime.tv_sec);
      SWAP_ENDIAN (pu.pr_ltime.tv_nsec);
      SWAP_ENDIAN (pu.pr_slptime.tv_sec);
      SWAP_ENDIAN (pu.pr_slptime.tv_nsec);
      SWAP_ENDIAN (pu.pr_wtime.tv_sec);
      SWAP_ENDIAN (pu.pr_wtime.tv_nsec);
      SWAP_ENDIAN (pu.pr_stoptime.tv_sec);
      SWAP_ENDIAN (pu.pr_stoptime.tv_nsec);
      SWAP_ENDIAN (pu.pr_minf);
      SWAP_ENDIAN (pu.pr_majf);
      SWAP_ENDIAN (pu.pr_nswap);
      SWAP_ENDIAN (pu.pr_inblk);
      SWAP_ENDIAN (pu.pr_oublk);
      SWAP_ENDIAN (pu.pr_msnd);
      SWAP_ENDIAN (pu.pr_mrcv);
      SWAP_ENDIAN (pu.pr_sigs);
      SWAP_ENDIAN (pu.pr_vctx);
      SWAP_ENDIAN (pu.pr_ictx);
      SWAP_ENDIAN (pu.pr_sysc);
      SWAP_ENDIAN (pu.pr_ioch);
    }
  pr_tstamp = timestruc2hr (tmp->pr_tstamp);
  pr_create = timestruc2hr (tmp->pr_create);
  pr_term = timestruc2hr (tmp->pr_term);
  pr_rtime = timestruc2hr (tmp->pr_rtime);
  pr_utime = timestruc2hr (tmp->pr_utime);
  pr_stime = timestruc2hr (tmp->pr_stime);
  pr_ttime = timestruc2hr (tmp->pr_ttime);
  pr_tftime = timestruc2hr (tmp->pr_tftime);
  pr_dftime = timestruc2hr (tmp->pr_dftime);
  pr_kftime = timestruc2hr (tmp->pr_kftime);
  pr_ltime = timestruc2hr (tmp->pr_ltime);
  pr_slptime = timestruc2hr (tmp->pr_slptime);
  pr_wtime = timestruc2hr (tmp->pr_wtime);
  pr_stoptime = timestruc2hr (tmp->pr_stoptime);
  pr_minf = tmp->pr_minf;
  pr_majf = tmp->pr_majf;
  pr_nswap = tmp->pr_nswap;
  pr_inblk = tmp->pr_inblk;
  pr_oublk = tmp->pr_oublk;
  pr_msnd = tmp->pr_msnd;
  pr_mrcv = tmp->pr_mrcv;
  pr_sigs = tmp->pr_sigs;
  pr_vctx = tmp->pr_vctx;
  pr_ictx = tmp->pr_ictx;
  pr_sysc = tmp->pr_sysc;
  pr_ioch = tmp->pr_ioch;
  return this;
}

struct timestruc_64
{ /* 64-bit timestruc_t */
  uint64_t tv_sec;          /* seconds */
  uint64_t tv_nsec;         /* and nanoseconds */
};

typedef struct
{
  id_t pr_lwpid;            /* lwp id.  0: process or defunct */
  int pr_count;             /* number of contributing lwps */
  timestruc_64 pr_tstamp;   /* current time stamp */
  timestruc_64 pr_create;   /* process/lwp creation time stamp */
  timestruc_64 pr_term;     /* process/lwp termination time stamp */
  timestruc_64 pr_rtime;    /* total lwp real (elapsed) time */
  timestruc_64 pr_utime;    /* user level cpu time */
  timestruc_64 pr_stime;    /* system call cpu time */
  timestruc_64 pr_ttime;    /* other system trap cpu time */
  timestruc_64 pr_tftime;   /* text page fault sleep time */
  timestruc_64 pr_dftime;   /* data page fault sleep time */
  timestruc_64 pr_kftime;   /* kernel page fault sleep time */
  timestruc_64 pr_ltime;    /* user lock wait sleep time */
  timestruc_64 pr_slptime;  /* all other sleep time */
  timestruc_64 pr_wtime;    /* wait-cpu (latency) time */
  timestruc_64 pr_stoptime; /* stopped time */
  timestruc_64 filltime[6]; /* filler for future expansion */
  uint64_t pr_minf;         /* minor page faults */
  uint64_t pr_majf;         /* major page faults */
  uint64_t pr_nswap;        /* swaps */
  uint64_t pr_inblk;        /* input blocks */
  uint64_t pr_oublk;        /* output blocks */
  uint64_t pr_msnd;         /* messages sent */
  uint64_t pr_mrcv;         /* messages received */
  uint64_t pr_sigs;         /* signals received */
  uint64_t pr_vctx;         /* voluntary context switches */
  uint64_t pr_ictx;         /* involuntary context switches */
  uint64_t pr_sysc;         /* system calls */
  uint64_t pr_ioch;         /* chars read and written */
  uint64_t filler[10];      /* filler for future expansion */
} raw_prusage_64;

uint64_t
PrUsage::bind64Size ()
{
  uint64_t bindSize = sizeof (raw_prusage_64);
  return bindSize;
}

PrUsage *
PrUsage::bind64 (void *p, bool need_swap_endian)
{
  if (p == NULL)
    {
      return NULL;
    }
  raw_prusage_64 pu, *tmp = (raw_prusage_64*) p;
  if (need_swap_endian)
    {
      pu = *tmp;
      tmp = &pu;
      SWAP_ENDIAN (pu.pr_tstamp.tv_sec);
      SWAP_ENDIAN (pu.pr_tstamp.tv_nsec);
      SWAP_ENDIAN (pu.pr_create.tv_sec);
      SWAP_ENDIAN (pu.pr_create.tv_nsec);
      SWAP_ENDIAN (pu.pr_term.tv_sec);
      SWAP_ENDIAN (pu.pr_term.tv_nsec);
      SWAP_ENDIAN (pu.pr_rtime.tv_sec);
      SWAP_ENDIAN (pu.pr_rtime.tv_nsec);
      SWAP_ENDIAN (pu.pr_utime.tv_sec);
      SWAP_ENDIAN (pu.pr_utime.tv_nsec);
      SWAP_ENDIAN (pu.pr_stime.tv_sec);
      SWAP_ENDIAN (pu.pr_stime.tv_nsec);
      SWAP_ENDIAN (pu.pr_ttime.tv_sec);
      SWAP_ENDIAN (pu.pr_ttime.tv_nsec);
      SWAP_ENDIAN (pu.pr_tftime.tv_sec);
      SWAP_ENDIAN (pu.pr_tftime.tv_nsec);
      SWAP_ENDIAN (pu.pr_dftime.tv_sec);
      SWAP_ENDIAN (pu.pr_dftime.tv_nsec);
      SWAP_ENDIAN (pu.pr_kftime.tv_sec);
      SWAP_ENDIAN (pu.pr_kftime.tv_nsec);
      SWAP_ENDIAN (pu.pr_ltime.tv_sec);
      SWAP_ENDIAN (pu.pr_ltime.tv_nsec);
      SWAP_ENDIAN (pu.pr_slptime.tv_sec);
      SWAP_ENDIAN (pu.pr_slptime.tv_nsec);
      SWAP_ENDIAN (pu.pr_wtime.tv_sec);
      SWAP_ENDIAN (pu.pr_wtime.tv_nsec);
      SWAP_ENDIAN (pu.pr_stoptime.tv_sec);
      SWAP_ENDIAN (pu.pr_stoptime.tv_nsec);
      SWAP_ENDIAN (pu.pr_minf);
      SWAP_ENDIAN (pu.pr_majf);
      SWAP_ENDIAN (pu.pr_nswap);
      SWAP_ENDIAN (pu.pr_inblk);
      SWAP_ENDIAN (pu.pr_oublk);
      SWAP_ENDIAN (pu.pr_msnd);
      SWAP_ENDIAN (pu.pr_mrcv);
      SWAP_ENDIAN (pu.pr_sigs);
      SWAP_ENDIAN (pu.pr_vctx);
      SWAP_ENDIAN (pu.pr_ictx);
      SWAP_ENDIAN (pu.pr_sysc);
      SWAP_ENDIAN (pu.pr_ioch);
    }

  pr_tstamp = timestruc2hr (tmp->pr_tstamp);
  pr_create = timestruc2hr (tmp->pr_create);
  pr_term = timestruc2hr (tmp->pr_term);
  pr_rtime = timestruc2hr (tmp->pr_rtime);
  pr_utime = timestruc2hr (tmp->pr_utime);
  pr_stime = timestruc2hr (tmp->pr_stime);
  pr_ttime = timestruc2hr (tmp->pr_ttime);
  pr_tftime = timestruc2hr (tmp->pr_tftime);
  pr_dftime = timestruc2hr (tmp->pr_dftime);
  pr_kftime = timestruc2hr (tmp->pr_kftime);
  pr_ltime = timestruc2hr (tmp->pr_ltime);
  pr_slptime = timestruc2hr (tmp->pr_slptime);
  pr_wtime = timestruc2hr (tmp->pr_wtime);
  pr_stoptime = timestruc2hr (tmp->pr_stoptime);
  pr_minf = tmp->pr_minf;
  pr_majf = tmp->pr_majf;
  pr_nswap = tmp->pr_nswap;
  pr_inblk = tmp->pr_inblk;
  pr_oublk = tmp->pr_oublk;
  pr_msnd = tmp->pr_msnd;
  pr_mrcv = tmp->pr_mrcv;
  pr_sigs = tmp->pr_sigs;
  pr_vctx = tmp->pr_vctx;
  pr_ictx = tmp->pr_ictx;
  pr_sysc = tmp->pr_sysc;
  pr_ioch = tmp->pr_ioch;
  return this;
}

Vector<long long> *
PrUsage::getMstateValues ()
{
  const PrUsage *prusage = this;
  Vector<long long> *states = new Vector<long long>;
  states->store (0, prusage->pr_utime);
  states->store (1, prusage->pr_stime);
  states->store (2, prusage->pr_ttime);
  states->store (3, prusage->pr_tftime);
  states->store (4, prusage->pr_dftime);
  states->store (5, prusage->pr_kftime);
  states->store (6, prusage->pr_ltime);
  states->store (7, prusage->pr_slptime);
  states->store (8, prusage->pr_wtime);
  states->store (9, prusage->pr_stoptime);
  assert (LMS_NUM_SOLARIS_MSTATES == states->size ());
  return states;
}

void* CommonPacket::jvm_overhead = NULL;

CommonPacket::CommonPacket ()
{
  for (int i = 0; i < NTAGS; i++)
    tags[i] = 0;
  tstamp = 0;
  jthread_TBR = NULL;
  frinfo = 0;
  leafpc = 0;
  nat_stack = NULL;
  user_stack = NULL;
}

int
CommonPacket::cmp (const void *a, const void *b)
{
  if ((*(CommonPacket **) a)->tstamp > (*(CommonPacket **) b)->tstamp)
    return 1;
  else if ((*(CommonPacket **) a)->tstamp < (*(CommonPacket **) b)->tstamp)
    return -1;
  else
    return 0;
}

void *
CommonPacket::getStack (VMode view_mode)
{
  if (view_mode == VMODE_MACHINE)
    return nat_stack;
  else if (view_mode == VMODE_USER)
    {
      if (jthread_TBR == JTHREAD_NONE || (jthread_TBR && jthread_TBR->is_system ()))
	return jvm_overhead;
    }
  else if (view_mode == VMODE_EXPERT)
    {
      Histable *hist = CallStack::getStackPC (user_stack, 0);
      if (hist->get_type () == Histable::INSTR)
	{
	  DbeInstr *instr = (DbeInstr*) hist;
	  if (instr->func == dbeSession->get_JUnknown_Function ())
	    return nat_stack;
	}
      else if (hist->get_type () == Histable::LINE)
	{
	  DbeLine *line = (DbeLine *) hist;
	  if (line->func == dbeSession->get_JUnknown_Function ())
	    return nat_stack;
	}
    }
  return user_stack;
}

Histable *
CommonPacket::getStackPC (int n, VMode view_mode)
{
  return CallStack::getStackPC (getStack (view_mode), n);
}

Vector<Histable*> *
CommonPacket::getStackPCs (VMode view_mode)
{
  return CallStack::getStackPCs (getStack (view_mode));
}

void *
getStack (VMode view_mode, DataView *dview, long idx)
{
  void *stack = NULL;
  if (view_mode == VMODE_MACHINE)
    stack = dview->getObjValue (PROP_MSTACK, idx);
  else if (view_mode == VMODE_USER)
    stack = dview->getObjValue (PROP_USTACK, idx);
  else if (view_mode == VMODE_EXPERT)
    stack = dview->getObjValue (PROP_XSTACK, idx);
  return stack;
}

int
stackSize (VMode view_mode, DataView *dview, long idx)
{
  return CallStack::stackSize (getStack (view_mode, dview, idx));
}

Histable *
getStackPC (int n, VMode view_mode, DataView *dview, long idx)
{
  return CallStack::getStackPC (getStack (view_mode, dview, idx), n);
}

Vector<Histable*> *
getStackPCs (VMode view_mode, DataView *dview, long idx)
{
  return CallStack::getStackPCs (getStack (view_mode, dview, idx));
}
Commit	Line	Data
fd67aa11	1	/* Copyright (C) 2021-2024 Free Software Foundation, Inc.
bb368aad VM	2	Contributed by Oracle.
	3
	4	This file is part of GNU Binutils.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3, or (at your option)
	9	any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, 51 Franklin Street - Fifth Floor, Boston,
	19	MA 02110-1301, USA. */
	20
	21	#include "config.h"
	22	#include "CallStack.h"
	23	#include "DbeSession.h"
	24	#include "Exp_Layout.h"
	25	#include "Experiment.h"
	26	#include "Function.h"
	27	#include "Table.h"
	28	#include "dbe_types.h"
	29	#include "util.h"
	30
	31	/*
	32	* PrUsage is a class which wraps access to the values of prusage
	33	* system structure. It was expanded to 64 bit entities in 2.7
	34	* (experiment version 6 & 7).
	35	*/
	36	PrUsage::PrUsage ()
	37	{
	38	pr_tstamp = pr_create = pr_term = pr_rtime = (hrtime_t) 0;
	39	pr_utime = pr_stime = pr_ttime = pr_tftime = pr_dftime = (hrtime_t) 0;
	40	pr_kftime = pr_ltime = pr_slptime = pr_wtime = pr_stoptime = (hrtime_t) 0;
	41
	42	pr_minf = pr_majf = pr_nswap = pr_inblk = pr_oublk = 0;
	43	pr_msnd = pr_mrcv = pr_sigs = pr_vctx = pr_ictx = pr_sysc = pr_ioch = 0;
	44	}
	45
	46	/*
	47	* Resource usage. /proc/<pid>/usage /proc/<pid>/lwp/<lwpid>/lwpusage
	48	*/
	49	struct timestruc_32
	50	{ /* v8 timestruc_t */
	51	uint32_t tv_sec; /* seconds */
	52	uint32_t tv_nsec; /* and nanoseconds */
	53	};
	54
	55	typedef struct ana_prusage
	56	{
	57	id_t pr_lwpid; /* lwp id. 0: process or defunct */
	58	int pr_count; /* number of contributing lwps */
	59	timestruc_32 pr_tstamp; /* current time stamp */
	60	timestruc_32 pr_create; /* process/lwp creation time stamp */
	61	timestruc_32 pr_term; /* process/lwp termination time stamp */
	62	timestruc_32 pr_rtime; /* total lwp real (elapsed) time */
	63	timestruc_32 pr_utime; /* user level cpu time */
	64	timestruc_32 pr_stime; /* system call cpu time */
	65	timestruc_32 pr_ttime; /* other system trap cpu time */
66	timestruc_32 pr_tftime; /* text page fault sleep time */
67	timestruc_32 pr_dftime; /* data page fault sleep time */
68	timestruc_32 pr_kftime; /* kernel page fault sleep time */
69	timestruc_32 pr_ltime; /* user lock wait sleep time */
70	timestruc_32 pr_slptime; /* all other sleep time */
71	timestruc_32 pr_wtime; /* wait-cpu (latency) time */
72	timestruc_32 pr_stoptime; /* stopped time */
73	timestruc_32 filltime[6]; /* filler for future expansion */
74	uint32_t pr_minf; /* minor page faults */
75	uint32_t pr_majf; /* major page faults */
76	uint32_t pr_nswap; /* swaps */
77	uint32_t pr_inblk; /* input blocks */
78	uint32_t pr_oublk; /* output blocks */
79	uint32_t pr_msnd; /* messages sent */
80	uint32_t pr_mrcv; /* messages received */
81	uint32_t pr_sigs; /* signals received */
82	uint32_t pr_vctx; /* voluntary context switches */
83	uint32_t pr_ictx; /* involuntary context switches */
84	uint32_t pr_sysc; /* system calls */
85	uint32_t pr_ioch; /* chars read and written */
86	uint32_t filler[10]; /* filler for future expansion */
87	} raw_prusage_32;
88
89	uint64_t
90	PrUsage::bind32Size ()
91	{
92	uint64_t bindSize = sizeof (raw_prusage_32);
93	return bindSize;
94	}
95
96	#define timestruc2hr(x) ((hrtime_t)(x).tv_sec*NANOSEC + (hrtime_t)(x).tv_nsec)
97
98	PrUsage *
99	PrUsage::bind32 (void *p, bool need_swap_endian)
100	{
101	if (p == NULL)
102	return NULL;
103	raw_prusage_32 pu, tmp = (raw_prusage_32) p;
104	if (need_swap_endian)
105	{
106	pu = *tmp;
107	tmp = &pu;
108	SWAP_ENDIAN (pu.pr_tstamp.tv_sec);
109	SWAP_ENDIAN (pu.pr_tstamp.tv_nsec);
110	SWAP_ENDIAN (pu.pr_create.tv_sec);
111	SWAP_ENDIAN (pu.pr_create.tv_nsec);
112	SWAP_ENDIAN (pu.pr_term.tv_sec);
113	SWAP_ENDIAN (pu.pr_term.tv_nsec);
114	SWAP_ENDIAN (pu.pr_rtime.tv_sec);
115	SWAP_ENDIAN (pu.pr_rtime.tv_nsec);
116	SWAP_ENDIAN (pu.pr_utime.tv_sec);
117	SWAP_ENDIAN (pu.pr_utime.tv_nsec);
118	SWAP_ENDIAN (pu.pr_stime.tv_sec);
119	SWAP_ENDIAN (pu.pr_stime.tv_nsec);
120	SWAP_ENDIAN (pu.pr_ttime.tv_sec);
121	SWAP_ENDIAN (pu.pr_ttime.tv_nsec);
122	SWAP_ENDIAN (pu.pr_tftime.tv_sec);
123	SWAP_ENDIAN (pu.pr_tftime.tv_nsec);
124	SWAP_ENDIAN (pu.pr_dftime.tv_sec);
125	SWAP_ENDIAN (pu.pr_dftime.tv_nsec);
126	SWAP_ENDIAN (pu.pr_kftime.tv_sec);
127	SWAP_ENDIAN (pu.pr_kftime.tv_nsec);
128	SWAP_ENDIAN (pu.pr_ltime.tv_sec);
129	SWAP_ENDIAN (pu.pr_ltime.tv_nsec);
130	SWAP_ENDIAN (pu.pr_slptime.tv_sec);
131	SWAP_ENDIAN (pu.pr_slptime.tv_nsec);
132	SWAP_ENDIAN (pu.pr_wtime.tv_sec);
133	SWAP_ENDIAN (pu.pr_wtime.tv_nsec);
134	SWAP_ENDIAN (pu.pr_stoptime.tv_sec);
135	SWAP_ENDIAN (pu.pr_stoptime.tv_nsec);
136	SWAP_ENDIAN (pu.pr_minf);
137	SWAP_ENDIAN (pu.pr_majf);
138	SWAP_ENDIAN (pu.pr_nswap);
139	SWAP_ENDIAN (pu.pr_inblk);
140	SWAP_ENDIAN (pu.pr_oublk);
141	SWAP_ENDIAN (pu.pr_msnd);
142	SWAP_ENDIAN (pu.pr_mrcv);
143	SWAP_ENDIAN (pu.pr_sigs);
144	SWAP_ENDIAN (pu.pr_vctx);
145	SWAP_ENDIAN (pu.pr_ictx);
146	SWAP_ENDIAN (pu.pr_sysc);
147	SWAP_ENDIAN (pu.pr_ioch);
148	}
149	pr_tstamp = timestruc2hr (tmp->pr_tstamp);
150	pr_create = timestruc2hr (tmp->pr_create);
151	pr_term = timestruc2hr (tmp->pr_term);
152	pr_rtime = timestruc2hr (tmp->pr_rtime);
153	pr_utime = timestruc2hr (tmp->pr_utime);
154	pr_stime = timestruc2hr (tmp->pr_stime);
155	pr_ttime = timestruc2hr (tmp->pr_ttime);
156	pr_tftime = timestruc2hr (tmp->pr_tftime);
157	pr_dftime = timestruc2hr (tmp->pr_dftime);
158	pr_kftime = timestruc2hr (tmp->pr_kftime);
159	pr_ltime = timestruc2hr (tmp->pr_ltime);
160	pr_slptime = timestruc2hr (tmp->pr_slptime);
161	pr_wtime = timestruc2hr (tmp->pr_wtime);
162	pr_stoptime = timestruc2hr (tmp->pr_stoptime);
163	pr_minf = tmp->pr_minf;
164	pr_majf = tmp->pr_majf;
165	pr_nswap = tmp->pr_nswap;
166	pr_inblk = tmp->pr_inblk;
167	pr_oublk = tmp->pr_oublk;
168	pr_msnd = tmp->pr_msnd;
169	pr_mrcv = tmp->pr_mrcv;
170	pr_sigs = tmp->pr_sigs;
171	pr_vctx = tmp->pr_vctx;
172	pr_ictx = tmp->pr_ictx;
173	pr_sysc = tmp->pr_sysc;
174	pr_ioch = tmp->pr_ioch;
175	return this;
176	}
177
178	struct timestruc_64
179	{ /* 64-bit timestruc_t */
180	uint64_t tv_sec; /* seconds */
181	uint64_t tv_nsec; /* and nanoseconds */
182	};
183
184	typedef struct
185	{
186	id_t pr_lwpid; /* lwp id. 0: process or defunct */
187	int pr_count; /* number of contributing lwps */
188	timestruc_64 pr_tstamp; /* current time stamp */
189	timestruc_64 pr_create; /* process/lwp creation time stamp */
190	timestruc_64 pr_term; /* process/lwp termination time stamp */
191	timestruc_64 pr_rtime; /* total lwp real (elapsed) time */
192	timestruc_64 pr_utime; /* user level cpu time */
193	timestruc_64 pr_stime; /* system call cpu time */
194	timestruc_64 pr_ttime; /* other system trap cpu time */
195	timestruc_64 pr_tftime; /* text page fault sleep time */
196	timestruc_64 pr_dftime; /* data page fault sleep time */
197	timestruc_64 pr_kftime; /* kernel page fault sleep time */
198	timestruc_64 pr_ltime; /* user lock wait sleep time */
199	timestruc_64 pr_slptime; /* all other sleep time */
200	timestruc_64 pr_wtime; /* wait-cpu (latency) time */
201	timestruc_64 pr_stoptime; /* stopped time */
202	timestruc_64 filltime[6]; /* filler for future expansion */
203	uint64_t pr_minf; /* minor page faults */
204	uint64_t pr_majf; /* major page faults */
205	uint64_t pr_nswap; /* swaps */
206	uint64_t pr_inblk; /* input blocks */
207	uint64_t pr_oublk; /* output blocks */
208	uint64_t pr_msnd; /* messages sent */
209	uint64_t pr_mrcv; /* messages received */
210	uint64_t pr_sigs; /* signals received */
211	uint64_t pr_vctx; /* voluntary context switches */
212	uint64_t pr_ictx; /* involuntary context switches */
213	uint64_t pr_sysc; /* system calls */
214	uint64_t pr_ioch; /* chars read and written */
215	uint64_t filler[10]; /* filler for future expansion */
216	} raw_prusage_64;
217
218	uint64_t
219	PrUsage::bind64Size ()
220	{
221	uint64_t bindSize = sizeof (raw_prusage_64);
222	return bindSize;
223	}
224
225	PrUsage *
226	PrUsage::bind64 (void *p, bool need_swap_endian)
227	{
228	if (p == NULL)
229	{
230	return NULL;
231	}
232	raw_prusage_64 pu, tmp = (raw_prusage_64) p;
233	if (need_swap_endian)
234	{
235	pu = *tmp;
236	tmp = &pu;
237	SWAP_ENDIAN (pu.pr_tstamp.tv_sec);
238	SWAP_ENDIAN (pu.pr_tstamp.tv_nsec);
239	SWAP_ENDIAN (pu.pr_create.tv_sec);
240	SWAP_ENDIAN (pu.pr_create.tv_nsec);
241	SWAP_ENDIAN (pu.pr_term.tv_sec);
242	SWAP_ENDIAN (pu.pr_term.tv_nsec);
243	SWAP_ENDIAN (pu.pr_rtime.tv_sec);
244	SWAP_ENDIAN (pu.pr_rtime.tv_nsec);
245	SWAP_ENDIAN (pu.pr_utime.tv_sec);
246	SWAP_ENDIAN (pu.pr_utime.tv_nsec);
247	SWAP_ENDIAN (pu.pr_stime.tv_sec);
248	SWAP_ENDIAN (pu.pr_stime.tv_nsec);
249	SWAP_ENDIAN (pu.pr_ttime.tv_sec);
250	SWAP_ENDIAN (pu.pr_ttime.tv_nsec);
251	SWAP_ENDIAN (pu.pr_tftime.tv_sec);
252	SWAP_ENDIAN (pu.pr_tftime.tv_nsec);
253	SWAP_ENDIAN (pu.pr_dftime.tv_sec);
254	SWAP_ENDIAN (pu.pr_dftime.tv_nsec);
255	SWAP_ENDIAN (pu.pr_kftime.tv_sec);
256	SWAP_ENDIAN (pu.pr_kftime.tv_nsec);
257	SWAP_ENDIAN (pu.pr_ltime.tv_sec);
258	SWAP_ENDIAN (pu.pr_ltime.tv_nsec);
259	SWAP_ENDIAN (pu.pr_slptime.tv_sec);
260	SWAP_ENDIAN (pu.pr_slptime.tv_nsec);
261	SWAP_ENDIAN (pu.pr_wtime.tv_sec);
262	SWAP_ENDIAN (pu.pr_wtime.tv_nsec);
263	SWAP_ENDIAN (pu.pr_stoptime.tv_sec);
264	SWAP_ENDIAN (pu.pr_stoptime.tv_nsec);
265	SWAP_ENDIAN (pu.pr_minf);
266	SWAP_ENDIAN (pu.pr_majf);
267	SWAP_ENDIAN (pu.pr_nswap);
268	SWAP_ENDIAN (pu.pr_inblk);
269	SWAP_ENDIAN (pu.pr_oublk);
270	SWAP_ENDIAN (pu.pr_msnd);
271	SWAP_ENDIAN (pu.pr_mrcv);
272	SWAP_ENDIAN (pu.pr_sigs);
273	SWAP_ENDIAN (pu.pr_vctx);
274	SWAP_ENDIAN (pu.pr_ictx);
275	SWAP_ENDIAN (pu.pr_sysc);
276	SWAP_ENDIAN (pu.pr_ioch);
277	}
278
279	pr_tstamp = timestruc2hr (tmp->pr_tstamp);
280	pr_create = timestruc2hr (tmp->pr_create);
281	pr_term = timestruc2hr (tmp->pr_term);
282	pr_rtime = timestruc2hr (tmp->pr_rtime);
283	pr_utime = timestruc2hr (tmp->pr_utime);
284	pr_stime = timestruc2hr (tmp->pr_stime);
285	pr_ttime = timestruc2hr (tmp->pr_ttime);
286	pr_tftime = timestruc2hr (tmp->pr_tftime);
287	pr_dftime = timestruc2hr (tmp->pr_dftime);
288	pr_kftime = timestruc2hr (tmp->pr_kftime);
289	pr_ltime = timestruc2hr (tmp->pr_ltime);
290	pr_slptime = timestruc2hr (tmp->pr_slptime);
291	pr_wtime = timestruc2hr (tmp->pr_wtime);
292	pr_stoptime = timestruc2hr (tmp->pr_stoptime);
293	pr_minf = tmp->pr_minf;
294	pr_majf = tmp->pr_majf;
295	pr_nswap = tmp->pr_nswap;
296	pr_inblk = tmp->pr_inblk;
297	pr_oublk = tmp->pr_oublk;
298	pr_msnd = tmp->pr_msnd;
299	pr_mrcv = tmp->pr_mrcv;
300	pr_sigs = tmp->pr_sigs;
301	pr_vctx = tmp->pr_vctx;
302	pr_ictx = tmp->pr_ictx;
303	pr_sysc = tmp->pr_sysc;
304	pr_ioch = tmp->pr_ioch;
305	return this;
306	}
307
308	Vector<long long> *
309	PrUsage::getMstateValues ()
310	{
311	const PrUsage *prusage = this;
312	Vector<long long> *states = new Vector<long long>;
313	states->store (0, prusage->pr_utime);
314	states->store (1, prusage->pr_stime);
315	states->store (2, prusage->pr_ttime);
316	states->store (3, prusage->pr_tftime);
317	states->store (4, prusage->pr_dftime);
318	states->store (5, prusage->pr_kftime);
319	states->store (6, prusage->pr_ltime);
320	states->store (7, prusage->pr_slptime);
321	states->store (8, prusage->pr_wtime);
322	states->store (9, prusage->pr_stoptime);
323	assert (LMS_NUM_SOLARIS_MSTATES == states->size ());
324	return states;
325	}
326
327	void* CommonPacket::jvm_overhead = NULL;
328
329	CommonPacket::CommonPacket ()
330	{
331	for (int i = 0; i < NTAGS; i++)
332	tags[i] = 0;
333	tstamp = 0;
334	jthread_TBR = NULL;
335	frinfo = 0;
336	leafpc = 0;
337	nat_stack = NULL;
338	user_stack = NULL;
339	}
340
341	int
342	CommonPacket::cmp (const void a, const void b)
343	{
344	if (((CommonPacket ) a)->tstamp > ((CommonPacket **) b)->tstamp)
345	return 1;
346	else if (((CommonPacket ) a)->tstamp < ((CommonPacket **) b)->tstamp)
347	return -1;
348	else
349	return 0;
350	}
351
352	void *
353	CommonPacket::getStack (VMode view_mode)
354	{
355	if (view_mode == VMODE_MACHINE)
356	return nat_stack;
357	else if (view_mode == VMODE_USER)
358	{
359	if (jthread_TBR == JTHREAD_NONE \|\| (jthread_TBR && jthread_TBR->is_system ()))
360	return jvm_overhead;
361	}
362	else if (view_mode == VMODE_EXPERT)
363	{
364	Histable *hist = CallStack::getStackPC (user_stack, 0);
365	if (hist->get_type () == Histable::INSTR)
366	{
367	DbeInstr instr = (DbeInstr) hist;
368	if (instr->func == dbeSession->get_JUnknown_Function ())
369	return nat_stack;
370	}
371	else if (hist->get_type () == Histable::LINE)
372	{
373	DbeLine line = (DbeLine ) hist;
374	if (line->func == dbeSession->get_JUnknown_Function ())
375	return nat_stack;
376	}
377	}
378	return user_stack;
379	}
380
381	Histable *
382	CommonPacket::getStackPC (int n, VMode view_mode)
383	{
384	return CallStack::getStackPC (getStack (view_mode), n);
385	}
386
387	Vector<Histable>
388	CommonPacket::getStackPCs (VMode view_mode)
389	{
390	return CallStack::getStackPCs (getStack (view_mode));
391	}
392
393	void *
394	getStack (VMode view_mode, DataView *dview, long idx)
395	{
396	void *stack = NULL;
397	if (view_mode == VMODE_MACHINE)
398	stack = dview->getObjValue (PROP_MSTACK, idx);
399	else if (view_mode == VMODE_USER)
400	stack = dview->getObjValue (PROP_USTACK, idx);
401	else if (view_mode == VMODE_EXPERT)
402	stack = dview->getObjValue (PROP_XSTACK, idx);
403	return stack;
404	}
405
406	int
407	stackSize (VMode view_mode, DataView *dview, long idx)
408	{
409	return CallStack::stackSize (getStack (view_mode, dview, idx));
410	}
411
412	Histable *
413	getStackPC (int n, VMode view_mode, DataView *dview, long idx)
414	{
415	return CallStack::getStackPC (getStack (view_mode, dview, idx), n);
416	}
417
418	Vector<Histable>
419	getStackPCs (VMode view_mode, DataView *dview, long idx)
420	{
421	return CallStack::getStackPCs (getStack (view_mode, dview, idx));
422	}