| The Gaudi Framework v32r1 (f65d50dc)

Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | List of all members
PfmCodeAnalyser Class Reference

`#include <GaudiProfiling/PfmCodeAnalyser.h>`

Collaboration diagram for PfmCodeAnalyser:
[legend]

## Public Member Functions
void | start ()
void | stop ()
void | stop_init ()

## Static Public Member Functions
static PfmCodeAnalyser & | Instance (const char *event0="UNHALTED_CORE_CYCLES", unsigned int cmask_v0=0, bool inv_v0=false, const char *event1="", unsigned int cmask_v1=0, bool inv_v1=false, const char *event2="", unsigned int cmask_v2=0, bool inv_v2=false, const char *event3="", unsigned int cmask_v3=0, bool inv_v3=false)

## Private Member Functions
| PfmCodeAnalyser (const char *event0, unsigned int cmask_v0, bool inv_v0, const char *event1, unsigned int cmask_v1, bool inv_v1, const char *event2, unsigned int cmask_v2, bool inv_v2, const char *event3, unsigned int cmask_v3, bool inv_v3)
| PfmCodeAnalyser (PfmCodeAnalyser const &)
PfmCodeAnalyser & | operator= (PfmCodeAnalyser const &)
| ~PfmCodeAnalyser ()

## Private Attributes
int | used_counters_number
int | nehalem
pfmlib_input_param_t | inp
pfmlib_output_param_t | outp
pfarg_ctx_t | ctx
pfarg_pmd_t | pd [NUM_PMDS]
pfarg_pmc_t | pc [NUM_PMCS]
pfarg_load_t | load_arg
int | fd
char | event_str [MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS][MAX_EVT_NAME_LEN]
bool | inv [MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
unsigned int | cmask [MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
pfmlib_core_input_param_t | params
pfmlib_nhm_input_param_t | nhm_params
int | ret
unsigned | i
unsigned long | sum [MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
unsigned | count
unsigned | overhead_avg [MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]

## Detailed Description

Definition at line 23 of file PfmCodeAnalyser.h.

## Constructor & Destructor Documentation

## ◆ PfmCodeAnalyser() [1/2]

PfmCodeAnalyser::PfmCodeAnalyser | ( | const char * | event0,
|  | unsigned int | cmask_v0,
|  | bool | inv_v0,
|  | const char * | event1,
|  | unsigned int | cmask_v1,
|  | bool | inv_v1,
|  | const char * | event2,
|  | unsigned int | cmask_v2,
|  | bool | inv_v2,
|  | const char * | event3,
|  | unsigned int | cmask_v3,
|  | bool | inv_v3
| ) |  |
| private

Definition at line 64 of file PfmCodeAnalyser.h.

66 {
67 int ax, bx, cx, dx;
68 cpuid( 1, ax, bx, cx, dx );
69 int sse4_2_mask = 1 << 20;
70 nehalem = cx & sse4_2_mask;
71 strcpy( event_str[0], event0 );
72 strcpy( event_str[1], event1 );
73 strcpy( event_str[2], event2 );
74 strcpy( event_str[3], event3 );
75 cmask[0] = cmask_v0;
76 cmask[1] = cmask_v1;
77 cmask[2] = cmask_v2;
78 cmask[3] = cmask_v3;
79 inv[0] = inv_v0;
80 inv[1] = inv_v1;
81 inv[2] = inv_v2;
82 inv[3] = inv_v3;
83 used_counters_number = 0;
84 for ( int i = 0; i < MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS; i++ ) {
85 if ( strlen( event_str[i] ) > 0 ) used_counters_number++;
86 }
87 for ( int i = 0; i < used_counters_number; i++ ) {
88 sum[i] = 0;
89 overhead_avg[i] = 0;
90 }
91 count = 0;
92 if ( pfm_initialize() != PFMLIB_SUCCESS ) {
93 printf( "Cannot initialize perfmon!!\nExiting...\n" );
94 exit( 0 );
95 }
96 while ( count < 3 ) {
97 start();
98 stop_init();
99 }
100 for ( int i = 0; i < used_counters_number; i++ ) { sum[i] = 0; }
101 count = 0;
102 while ( count < 10 ) {
103 start();
104 stop_init();
105 }
106 for ( int i = 0; i < used_counters_number; i++ ) {
107 overhead_avg[i] = sum[i] / count;
108 sum[i] = 0;
109 }
110 count = 0;
111 }
MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS
#define MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS
Definition: PfmCodeAnalyser.h:19
cpuid
#define cpuid(func, eax, ebx, ecx, edx)
Definition: PfmCodeAnalyser.h:20
PFMLIB_SUCCESS
#define PFMLIB_SUCCESS
Definition: pfmlib.h:267
PfmCodeAnalyser::event_str
char event_str[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS][MAX_EVT_NAME_LEN]
Definition: PfmCodeAnalyser.h:34
PfmCodeAnalyser::count
unsigned count
Definition: PfmCodeAnalyser.h:42
PfmCodeAnalyser::cmask
unsigned int cmask[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:36
std::exit
T exit(T... args)
std::strlen
T strlen(T... args)
PfmCodeAnalyser::overhead_avg
unsigned overhead_avg[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:43
PfmCodeAnalyser::sum
unsigned long sum[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:41
pfm_initialize
pfm_err_t pfm_initialize(void)
std::strcpy
T strcpy(T... args)
PfmCodeAnalyser::used_counters_number
int used_counters_number
Definition: PfmCodeAnalyser.h:25
PfmCodeAnalyser::nehalem
int nehalem
Definition: PfmCodeAnalyser.h:26
PfmCodeAnalyser::stop_init
void stop_init()
Definition: PfmCodeAnalyser.h:205
PfmCodeAnalyser::inv
bool inv[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:35
std::printf
T printf(T... args)
PfmCodeAnalyser::start
void start()
Definition: PfmCodeAnalyser.h:124
PfmCodeAnalyser::i
unsigned i
Definition: PfmCodeAnalyser.h:40

## ◆ PfmCodeAnalyser() [2/2]

PfmCodeAnalyser::PfmCodeAnalyser | ( | PfmCodeAnalyser const & |  | ) |
| private

## ◆ ~PfmCodeAnalyser()

PfmCodeAnalyser::~PfmCodeAnalyser | ( |  | ) |
| private

Definition at line 217 of file PfmCodeAnalyser.h.

217 {
218 for ( int i = 0; i < used_counters_number; i++ ) {
219 printf( "Event: %s\nTotal count:%lu\nNumber of counts:%u\nAverage count:%f\nOverhead removed:%u\n", event_str[i],
220 sum[i], count, (double)sum[i] / count, overhead_avg[i] );
221 }
222 }
PfmCodeAnalyser::event_str
char event_str[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS][MAX_EVT_NAME_LEN]
Definition: PfmCodeAnalyser.h:34
PfmCodeAnalyser::count
unsigned count
Definition: PfmCodeAnalyser.h:42
PfmCodeAnalyser::overhead_avg
unsigned overhead_avg[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:43
PfmCodeAnalyser::sum
unsigned long sum[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:41
PfmCodeAnalyser::used_counters_number
int used_counters_number
Definition: PfmCodeAnalyser.h:25
std::printf
T printf(T... args)
PfmCodeAnalyser::i
unsigned i
Definition: PfmCodeAnalyser.h:40

## Member Function Documentation

## ◆ Instance()

PfmCodeAnalyser & PfmCodeAnalyser::Instance | ( | const char * | event0 = `"UNHALTED_CORE_CYCLES"`,
|  | unsigned int | cmask_v0 = `0`,
|  | bool | inv_v0 = `false`,
|  | const char * | event1 = `""`,
|  | unsigned int | cmask_v1 = `0`,
|  | bool | inv_v1 = `false`,
|  | const char * | event2 = `""`,
|  | unsigned int | cmask_v2 = `0`,
|  | bool | inv_v2 = `false`,
|  | const char * | event3 = `""`,
|  | unsigned int | cmask_v3 = `0`,
|  | bool | inv_v3 = `false`
| ) |  |
| static

Definition at line 113 of file PfmCodeAnalyser.h.

116 {
117 static PfmCodeAnalyser theSingleton( event0, cmask_v0, inv_v0, event1, cmask_v1, inv_v1, event2, cmask_v2, inv_v2,
118 event3, cmask_v3, inv_v3 );
119 return theSingleton;
120 }
PfmCodeAnalyser
Definition: PfmCodeAnalyser.h:23

## ◆ operator=()

PfmCodeAnalyser& PfmCodeAnalyser::operator= | ( | PfmCodeAnalyser const & |  | ) |
| private

## ◆ start()

void PfmCodeAnalyser::start | ( |  | ) |

Definition at line 124 of file PfmCodeAnalyser.h.

124 {
125 memset( &ctx, 0, sizeof( ctx ) );
126 memset( &inp, 0, sizeof( inp ) );
127 memset( &outp, 0, sizeof( outp ) );
128 memset( pd, 0, sizeof( pd ) );
129 memset( pc, 0, sizeof( pc ) );
130 memset( &load_arg, 0, sizeof( load_arg ) );
131 memset( &params, 0, sizeof( params ) );
132 for ( int i = 0; i < used_counters_number; i++ ) {
133 ret = pfm_find_full_event( event_str[i], &inp.pfp_events[i] );
134 if ( ret != PFMLIB_SUCCESS ) {
135 fprintf( stderr, "ERROR: cannot find event: %s\naborting...\n", event_str[i] );
136 exit( 1 );
137 }
138 }
139 inp.pfp_dfl_plm = PFM_PLM3;
140 inp.pfp_event_count = used_counters_number;
141 for ( int i = 0; i < used_counters_number; i++ ) {
142 if ( inv[i] ) {
143 ( params.pfp_core_counters[i] ).flags |= PFM_CORE_SEL_INV;
144 ( nhm_params.pfp_nhm_counters[i] ).flags |= PFM_NHM_SEL_INV;
145 }
146 if ( cmask[i] > 0 ) {
147 ( params.pfp_core_counters[i] ).cnt_mask = cmask[i];
148 ( nhm_params.pfp_nhm_counters[i] ).cnt_mask = cmask[i];
149 }
150 }
151 if ( nehalem ) {
152 ret = pfm_dispatch_events( &inp, &nhm_params, &outp, NULL );
153 } else {
154 ret = pfm_dispatch_events( &inp, &params, &outp, NULL );
155 }
156 if ( ret != PFMLIB_SUCCESS ) {
157 fprintf( stderr, "ERROR: cannot dispatch events: %s\naborting...\n", pfm_strerror( ret ) );
158 exit( 1 );
159 }
160 for ( unsigned int i = 0; i < outp.pfp_pmc_count; i++ ) {
161 pc[i].reg_num = outp.pfp_pmcs[i].reg_num;
162 pc[i].reg_value = outp.pfp_pmcs[i].reg_value;
163 }
164 for ( unsigned int i = 0; i < outp.pfp_pmd_count; i++ ) {
165 pd[i].reg_num = outp.pfp_pmds[i].reg_num;
166 pd[i].reg_value = 0;
167 }
168 fd = pfm_create_context( &ctx, NULL, 0, 0 );
169 if ( fd == -1 ) {
170 fprintf( stderr, "ERROR: Context not created\naborting...\n" );
171 exit( 1 );
172 }
173 if ( pfm_write_pmcs( fd, pc, outp.pfp_pmc_count ) == -1 ) {
174 fprintf( stderr, "ERROR: Could not write pmcs\naborting...\n" );
175 exit( 1 );
176 }
177 if ( pfm_write_pmds( fd, pd, outp.pfp_pmd_count ) == -1 ) {
178 fprintf( stderr, "ERROR: Could not write pmds\naborting...\n" );
179 exit( 1 );
180 }
181 load_arg.load_pid = getpid();
182 if ( pfm_load_context( fd, &load_arg ) == -1 ) {
183 fprintf( stderr, "ERROR: Could not load context\naborting...\n" );
184 exit( 1 );
185 }
186 pfm_start( fd, NULL );
187 }
pfmlib_output_param_t::pfp_pmds
pfmlib_reg_t pfp_pmds[PFMLIB_MAX_PMDS]
Definition: pfmlib.h:129
PfmCodeAnalyser::load_arg
pfarg_load_t load_arg
Definition: PfmCodeAnalyser.h:32
pfm_write_pmds
os_err_t pfm_write_pmds(int fd, pfarg_pmd_t *pmds, int count)
PFM_NHM_SEL_INV
#define PFM_NHM_SEL_INV
Definition: pfmlib_intel_nhm.h:103
pfm_create_context
os_err_t pfm_create_context(pfarg_ctx_t *ctx, char *smpl_name, void *smpl_arg, size_t smpl_size)
PFM_PLM3
#define PFM_PLM3
Definition: pfmlib.h:53
pfm_strerror
char * pfm_strerror(int code)
PfmCodeAnalyser::nhm_params
pfmlib_nhm_input_param_t nhm_params
Definition: PfmCodeAnalyser.h:38
PfmCodeAnalyser::fd
int fd
Definition: PfmCodeAnalyser.h:33
pfmlib_input_param_t::pfp_events
pfmlib_event_t pfp_events[PFMLIB_MAX_PMCS]
Definition: pfmlib.h:112
PFM_CORE_SEL_INV
#define PFM_CORE_SEL_INV
Definition: pfmlib_core.h:68
pfmlib_nhm_input_param_t::pfp_nhm_counters
pfmlib_nhm_counter_t pfp_nhm_counters[PMU_NHM_NUM_COUNTERS]
Definition: pfmlib_intel_nhm.h:139
PfmCodeAnalyser::ctx
pfarg_ctx_t ctx
Definition: PfmCodeAnalyser.h:29
PFMLIB_SUCCESS
#define PFMLIB_SUCCESS
Definition: pfmlib.h:267
PfmCodeAnalyser::event_str
char event_str[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS][MAX_EVT_NAME_LEN]
Definition: PfmCodeAnalyser.h:34
pfmlib_input_param_t::pfp_dfl_plm
unsigned int pfp_dfl_plm
Definition: pfmlib.h:109
pfarg_pmd_t::reg_num
uint16_t reg_num
Definition: perfmon_v2.h:39
PfmCodeAnalyser::ret
int ret
Definition: PfmCodeAnalyser.h:39
std::memset
T memset(T... args)
pfm_write_pmcs
os_err_t pfm_write_pmcs(int fd, pfarg_pmc_t *pmcs, int count)
pfm_dispatch_events
pfm_err_t pfm_dispatch_events(pfmlib_input_param_t *p, void *model_in, pfmlib_output_param_t *q, void *model_out)
pfmlib_output_param_t::pfp_pmc_count
unsigned int pfp_pmc_count
Definition: pfmlib.h:126
pfmlib_reg_t::reg_value
unsigned long long reg_value
Definition: pfmlib.h:97
pfmlib_output_param_t::pfp_pmd_count
unsigned int pfp_pmd_count
Definition: pfmlib.h:127
pfm_find_full_event
pfm_err_t pfm_find_full_event(const char *str, pfmlib_event_t *e)
PfmCodeAnalyser::params
pfmlib_core_input_param_t params
Definition: PfmCodeAnalyser.h:37
PfmCodeAnalyser::cmask
unsigned int cmask[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:36
std::exit
T exit(T... args)
PfmCodeAnalyser::pc
pfarg_pmc_t pc[NUM_PMCS]
Definition: PfmCodeAnalyser.h:31
pfmlib_reg_t::reg_num
unsigned int reg_num
Definition: pfmlib.h:99
PfmCodeAnalyser::pd
pfarg_pmd_t pd[NUM_PMDS]
Definition: PfmCodeAnalyser.h:30
pfarg_pmc_t::reg_num
uint16_t reg_num
Definition: perfmon_v2.h:28
pfm_start
os_err_t pfm_start(int fd, pfarg_start_t *start)
pfarg_load_t::load_pid
uint32_t load_pid
Definition: perfmon_v2.h:69
PfmCodeAnalyser::used_counters_number
int used_counters_number
Definition: PfmCodeAnalyser.h:25
PfmCodeAnalyser::nehalem
int nehalem
Definition: PfmCodeAnalyser.h:26
PfmCodeAnalyser::inp
pfmlib_input_param_t inp
Definition: PfmCodeAnalyser.h:27
pfm_load_context
os_err_t pfm_load_context(int fd, pfarg_load_t *load)
pfarg_pmc_t::reg_value
uint64_t reg_value
Definition: perfmon_v2.h:31
PfmCodeAnalyser::inv
bool inv[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:35
pfmlib_output_param_t::pfp_pmcs
pfmlib_reg_t pfp_pmcs[PFMLIB_MAX_PMCS]
Definition: pfmlib.h:128
pfmlib_core_input_param_t::pfp_core_counters
pfmlib_core_counter_t pfp_core_counters[PMU_CORE_NUM_COUNTERS]
Definition: pfmlib_core.h:79
PfmCodeAnalyser::outp
pfmlib_output_param_t outp
Definition: PfmCodeAnalyser.h:28
std::fprintf
T fprintf(T... args)
pfarg_pmd_t::reg_value
uint64_t reg_value
Definition: perfmon_v2.h:42
pfmlib_input_param_t::pfp_event_count
unsigned int pfp_event_count
Definition: pfmlib.h:108
PfmCodeAnalyser::i
unsigned i
Definition: PfmCodeAnalyser.h:40

## ◆ stop()

void PfmCodeAnalyser::stop | ( |  | ) |

Definition at line 193 of file PfmCodeAnalyser.h.

193 {
194 pfm_stop( fd );
195 if ( pfm_read_pmds( fd, pd, inp.pfp_event_count ) == -1 ) {
196 fprintf( stderr, "ERROR: Could not read pmds\naborting...\n" );
197 exit( 1 );
198 }
199
200 for ( int i = 0; i < used_counters_number; i++ ) { sum[i] += ( pd[i].reg_value - overhead_avg[i] ); }
201 count++;
202 close( fd );
203 }
PfmCodeAnalyser::fd
int fd
Definition: PfmCodeAnalyser.h:33
PfmCodeAnalyser::count
unsigned count
Definition: PfmCodeAnalyser.h:42
std::exit
T exit(T... args)
PfmCodeAnalyser::pd
pfarg_pmd_t pd[NUM_PMDS]
Definition: PfmCodeAnalyser.h:30
PfmCodeAnalyser::overhead_avg
unsigned overhead_avg[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:43
PfmCodeAnalyser::sum
unsigned long sum[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:41
PfmCodeAnalyser::used_counters_number
int used_counters_number
Definition: PfmCodeAnalyser.h:25
PfmCodeAnalyser::inp
pfmlib_input_param_t inp
Definition: PfmCodeAnalyser.h:27
pfm_read_pmds
os_err_t pfm_read_pmds(int fd, pfarg_pmd_t *pmds, int count)
pfm_stop
os_err_t pfm_stop(int fd)
std::fprintf
T fprintf(T... args)
pfarg_pmd_t::reg_value
uint64_t reg_value
Definition: perfmon_v2.h:42
pfmlib_input_param_t::pfp_event_count
unsigned int pfp_event_count
Definition: pfmlib.h:108
PfmCodeAnalyser::i
unsigned i
Definition: PfmCodeAnalyser.h:40

## ◆ stop_init()

void PfmCodeAnalyser::stop_init | ( |  | ) |

Definition at line 205 of file PfmCodeAnalyser.h.

205 {
206 pfm_stop( fd );
207 if ( pfm_read_pmds( fd, pd, inp.pfp_event_count ) == -1 ) {
208 fprintf( stderr, "ERROR: Could not read pmds\naborting...\n" );
209 exit( 1 );
210 }
211
212 for ( int i = 0; i < used_counters_number; i++ ) { sum[i] += ( pd[i].reg_value ); }
213 count++;
214 close( fd );
215 }
PfmCodeAnalyser::fd
int fd
Definition: PfmCodeAnalyser.h:33
PfmCodeAnalyser::count
unsigned count
Definition: PfmCodeAnalyser.h:42
std::exit
T exit(T... args)
PfmCodeAnalyser::pd
pfarg_pmd_t pd[NUM_PMDS]
Definition: PfmCodeAnalyser.h:30
PfmCodeAnalyser::sum
unsigned long sum[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
Definition: PfmCodeAnalyser.h:41
PfmCodeAnalyser::used_counters_number
int used_counters_number
Definition: PfmCodeAnalyser.h:25
PfmCodeAnalyser::inp
pfmlib_input_param_t inp
Definition: PfmCodeAnalyser.h:27
pfm_read_pmds
os_err_t pfm_read_pmds(int fd, pfarg_pmd_t *pmds, int count)
pfm_stop
os_err_t pfm_stop(int fd)
std::fprintf
T fprintf(T... args)
pfarg_pmd_t::reg_value
uint64_t reg_value
Definition: perfmon_v2.h:42
pfmlib_input_param_t::pfp_event_count
unsigned int pfp_event_count
Definition: pfmlib.h:108
PfmCodeAnalyser::i
unsigned i
Definition: PfmCodeAnalyser.h:40

## Member Data Documentation

## ◆ cmask

unsigned int PfmCodeAnalyser::cmask[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
| private

Definition at line 36 of file PfmCodeAnalyser.h.

## ◆ count

unsigned PfmCodeAnalyser::count
| private

Definition at line 42 of file PfmCodeAnalyser.h.

## ◆ ctx

pfarg_ctx_t PfmCodeAnalyser::ctx
| private

Definition at line 29 of file PfmCodeAnalyser.h.

## ◆ event_str

char PfmCodeAnalyser::event_str[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS][MAX_EVT_NAME_LEN]
| private

Definition at line 34 of file PfmCodeAnalyser.h.

## ◆ fd

int PfmCodeAnalyser::fd
| private

Definition at line 33 of file PfmCodeAnalyser.h.

## ◆ i

unsigned PfmCodeAnalyser::i
| private

Definition at line 40 of file PfmCodeAnalyser.h.

## ◆ inp

pfmlib_input_param_t PfmCodeAnalyser::inp
| private

Definition at line 27 of file PfmCodeAnalyser.h.

## ◆ inv

bool PfmCodeAnalyser::inv[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
| private

Definition at line 35 of file PfmCodeAnalyser.h.

## ◆ load_arg

pfarg_load_t PfmCodeAnalyser::load_arg
| private

Definition at line 32 of file PfmCodeAnalyser.h.

## ◆ nehalem

int PfmCodeAnalyser::nehalem
| private

Definition at line 26 of file PfmCodeAnalyser.h.

## ◆ nhm_params

pfmlib_nhm_input_param_t PfmCodeAnalyser::nhm_params
| private

Definition at line 38 of file PfmCodeAnalyser.h.

## ◆ outp

pfmlib_output_param_t PfmCodeAnalyser::outp
| private

Definition at line 28 of file PfmCodeAnalyser.h.

## ◆ overhead_avg

unsigned PfmCodeAnalyser::overhead_avg[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
| private

Definition at line 43 of file PfmCodeAnalyser.h.

## ◆ params

pfmlib_core_input_param_t PfmCodeAnalyser::params
| private

Definition at line 37 of file PfmCodeAnalyser.h.

## ◆ pc

pfarg_pmc_t PfmCodeAnalyser::pc[NUM_PMCS]
| private

Definition at line 31 of file PfmCodeAnalyser.h.

## ◆ pd

pfarg_pmd_t PfmCodeAnalyser::pd[NUM_PMDS]
| private

Definition at line 30 of file PfmCodeAnalyser.h.

## ◆ ret

int PfmCodeAnalyser::ret
| private

Definition at line 39 of file PfmCodeAnalyser.h.

## ◆ sum

unsigned long PfmCodeAnalyser::sum[MAX_NUMBER_OF_PROGRAMMABLE_COUNTERS]
| private

Definition at line 41 of file PfmCodeAnalyser.h.

## ◆ used_counters_number

int PfmCodeAnalyser::used_counters_number
| private

Definition at line 25 of file PfmCodeAnalyser.h.

The documentation for this class was generated from the following file:

- GaudiProfiling/GaudiProfiling/PfmCodeAnalyser.h