radix-engine 1.3.1

Reference implementation of Radix Engine, from the Radix DLT project.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use crate::transaction::ResourcesUsage;
use perfcnt::{
    linux::{HardwareEventType, PerfCounterBuilderLinux},
    AbstractPerfCounter, PerfCounter,
};
use radix_engine_profiling::info_alloc::*;

/// CPU cycles tracker
///
/// Performance counters are used to read Reference CPU cycles.
pub struct InfoCpu {
    perf: PerfCounter,
}

impl InfoCpu {
    pub fn new() -> Self {
        Self {
            perf: PerfCounterBuilderLinux::from_hardware_event(HardwareEventType::RefCPUCycles)
                .finish()
                .expect("Failed to initialize CPU performance counter"),
        }
    }

    pub fn start_measurement(&self) {
        self.perf
            .start()
            .expect("Failed to start CPU performance counter");
    }

    pub fn end_measurement(&mut self) -> u64 {
        self.perf
            .stop()
            .expect("Failed to stop CPU performance counter");
        self.perf
            .read()
            .expect("Failed to read value of CPU performance counter")
    }
}

pub struct ResourcesTracker {
    cpu: InfoCpu,
}

impl ResourcesTracker {
    pub fn start_measurement() -> Self {
        let ret = Self {
            cpu: InfoCpu::new(),
        };

        ret.cpu.start_measurement();
        INFO_ALLOC.set_enable(true);
        INFO_ALLOC.reset_counters();
        ret
    }

    pub fn end_measurement(&mut self) -> ResourcesUsage {
        let cpu_cycles = self.cpu.end_measurement();
        let (heap_allocations_sum, _heap_current_level, heap_peak_memory) =
            INFO_ALLOC.get_counters_value();
        INFO_ALLOC.set_enable(false);
        ResourcesUsage {
            heap_allocations_sum,
            heap_peak_memory,
            cpu_cycles,
        }
    }
}