Skip to content

Commit

Permalink
lazily return errors in profiler initialization
Browse files Browse the repository at this point in the history 
Signed-off-by: Daniel Hodges <[email protected]>
  • Loading branch information
@hodgesds
hodgesds committed Sep 14, 2021
1 parent 3ce7e7d commit bfd63eb
Show file tree
Hide file tree
Showing 3 changed files with 123 additions and 81 deletions.
103 changes: 62 additions & 41 deletions cache_profiler.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,177 +64,198 @@ type cacheProfiler struct {
// NewCacheProfiler returns a new cache profiler.
func NewCacheProfiler(pid, cpu int, opts ...int) (CacheProfiler, error) {
profilers := map[int]Profiler{}
var e error

// L1 data
op := unix.PERF_COUNT_HW_CACHE_OP_READ
result := unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
l1dataReadHit, err := NewL1DataProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[L1DataReadHit] = l1dataReadHit
}
profilers[L1DataReadHit] = l1dataReadHit

op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
l1dataReadMiss, err := NewL1DataProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[L1DataReadMiss] = l1dataReadMiss
}
profilers[L1DataReadMiss] = l1dataReadMiss

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
l1dataWriteHit, err := NewL1DataProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[L1DataWriteHit] = l1dataWriteHit
}
profilers[L1DataWriteHit] = l1dataWriteHit

// L1 instruction
op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
l1InstrReadMiss, err := NewL1InstrProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[L1InstrReadMiss] = l1InstrReadMiss
}
profilers[L1InstrReadMiss] = l1InstrReadMiss

// Last Level
op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
llReadHit, err := NewLLCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[LLReadHit] = llReadHit
}
profilers[LLReadHit] = llReadHit

op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
llReadMiss, err := NewLLCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[LLReadMiss] = llReadMiss
}
profilers[LLReadMiss] = llReadMiss

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
llWriteHit, err := NewLLCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[LLWriteHit] = llWriteHit
}
profilers[LLWriteHit] = llWriteHit

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
llWriteMiss, err := NewLLCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[LLWriteMiss] = llWriteMiss
}
profilers[LLWriteMiss] = llWriteMiss

// dTLB
op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
dTLBReadHit, err := NewDataTLBProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[DataTLBReadHit] = dTLBReadHit
}
profilers[DataTLBReadHit] = dTLBReadHit

op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
dTLBReadMiss, err := NewDataTLBProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[DataTLBReadMiss] = dTLBReadMiss
}
profilers[DataTLBReadMiss] = dTLBReadMiss

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
dTLBWriteHit, err := NewDataTLBProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[DataTLBWriteHit] = dTLBWriteHit
}
profilers[DataTLBWriteHit] = dTLBWriteHit

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
dTLBWriteMiss, err := NewDataTLBProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[DataTLBWriteMiss] = dTLBWriteMiss
}
profilers[DataTLBWriteMiss] = dTLBWriteMiss

// iTLB
op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
iTLBReadHit, err := NewInstrTLBProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[InstrTLBReadHit] = iTLBReadHit
}
profilers[InstrTLBReadHit] = iTLBReadHit

op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
iTLBReadMiss, err := NewInstrTLBProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[InstrTLBReadMiss] = iTLBReadMiss
}
profilers[InstrTLBReadMiss] = iTLBReadMiss

// BPU
op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
bpuReadHit, err := NewBPUProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[BPUReadHit] = bpuReadHit
}
profilers[BPUReadHit] = bpuReadHit

op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
bpuReadMiss, err := NewBPUProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[BPUReadMiss] = bpuReadMiss
}
profilers[BPUReadMiss] = bpuReadMiss

// Node
op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
nodeReadHit, err := NewNodeCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[NodeCacheReadHit] = nodeReadHit
}
profilers[NodeCacheReadHit] = nodeReadHit

op = unix.PERF_COUNT_HW_CACHE_OP_READ
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
nodeReadMiss, err := NewNodeCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[NodeCacheReadMiss] = nodeReadMiss
}
profilers[NodeCacheReadMiss] = nodeReadMiss

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_ACCESS
nodeWriteHit, err := NewNodeCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[NodeCacheWriteHit] = nodeWriteHit
}
profilers[NodeCacheWriteHit] = nodeWriteHit

op = unix.PERF_COUNT_HW_CACHE_OP_WRITE
result = unix.PERF_COUNT_HW_CACHE_RESULT_MISS
nodeWriteMiss, err := NewNodeCacheProfiler(pid, cpu, op, result, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[NodeCacheWriteMiss] = nodeWriteMiss
}
profilers[NodeCacheWriteMiss] = nodeWriteMiss

return &cacheProfiler{
profilers: profilers,
}, nil
}, e
}

// Start is used to start the CacheProfiler, it will return an error if no
Expand Down
53 changes: 32 additions & 21 deletions hardware_profiler.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,71 +15,82 @@ type hardwareProfiler struct {

// NewHardwareProfiler returns a new hardware profiler.
func NewHardwareProfiler(pid, cpu int, opts ...int) (HardwareProfiler, error) {
var e error
profilers := map[int]Profiler{}

cpuCycleProfiler, err := NewCPUCycleProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_CPU_CYCLES] = cpuCycleProfiler
}
profilers[unix.PERF_COUNT_HW_CPU_CYCLES] = cpuCycleProfiler

instrProfiler, err := NewInstrProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_INSTRUCTIONS] = instrProfiler
}
profilers[unix.PERF_COUNT_HW_INSTRUCTIONS] = instrProfiler

cacheRefProfiler, err := NewCacheRefProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_CACHE_REFERENCES] = cacheRefProfiler
}
profilers[unix.PERF_COUNT_HW_CACHE_REFERENCES] = cacheRefProfiler

cacheMissesProfiler, err := NewCacheMissesProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_CACHE_MISSES] = cacheMissesProfiler
}
profilers[unix.PERF_COUNT_HW_CACHE_MISSES] = cacheMissesProfiler

branchInstrProfiler, err := NewBranchInstrProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = branchInstrProfiler
}
profilers[unix.PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = branchInstrProfiler

branchMissesProfiler, err := NewBranchMissesProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_BRANCH_MISSES] = branchMissesProfiler
}
profilers[unix.PERF_COUNT_HW_BRANCH_MISSES] = branchMissesProfiler

busCyclesProfiler, err := NewBusCyclesProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_BUS_CYCLES] = busCyclesProfiler
}
profilers[unix.PERF_COUNT_HW_BUS_CYCLES] = busCyclesProfiler

stalledCyclesFrontProfiler, err := NewStalledCyclesFrontProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = stalledCyclesFrontProfiler
}
profilers[unix.PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = stalledCyclesFrontProfiler

stalledCyclesBackProfiler, err := NewStalledCyclesBackProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = stalledCyclesBackProfiler
}
profilers[unix.PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = stalledCyclesBackProfiler

refCPUCyclesProfiler, err := NewRefCPUCyclesProfiler(pid, cpu, opts...)
if err != nil {
return nil, err
e = multierr.Append(e, err)
} else {
profilers[unix.PERF_COUNT_HW_REF_CPU_CYCLES] = refCPUCyclesProfiler
}
profilers[unix.PERF_COUNT_HW_REF_CPU_CYCLES] = refCPUCyclesProfiler

return &hardwareProfiler{
profilers: profilers,
}, nil
}, e
}

// Start is used to start the HardwareProfiler.
Expand Down
Loading

0 comments on commit bfd63eb

Please sign in to comment.