lambdust 0.1.1

A Scheme dialect with gradual typing and effect systems
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! Runtime profiling and performance analysis components.

use std::collections::HashMap;
use std::time::{Duration, Instant};

/// Profiling information.
#[derive(Debug, Clone)]
pub struct ProfilingInfo {
    /// Function call counts
    pub call_counts: HashMap<String, usize>,
    /// Function execution times
    pub execution_times: HashMap<String, Duration>,
    /// Memory allocation tracking
    pub allocations: HashMap<String, AllocationInfo>,
    /// Hot spots (most time-consuming functions)
    pub hot_spots: Vec<HotSpot>,
}

/// Memory allocation information.
#[derive(Debug, Clone)]
pub struct AllocationInfo {
    /// Number of allocations
    pub count: usize,
    /// Total bytes allocated
    pub bytes: usize,
    /// Average allocation size
    pub avg_size: f64,
}

/// Hot spot in profiling.
#[derive(Debug, Clone)]
pub struct HotSpot {
    /// Function name
    pub function: String,
    /// Percentage of total execution time
    pub time_percentage: f64,
    /// Number of calls
    pub call_count: usize,
    /// Average time per call
    pub avg_time: Duration,
}

/// Profiler for runtime performance analysis.
#[derive(Debug)]
pub struct Profiler {
    /// Profiling data
    profiling_info: ProfilingInfo,
    /// Start time
    start_time: Instant,
}

impl Profiler {
    /// Creates a new profiler.
    pub fn new() -> Self {
        Self {
            profiling_info: ProfilingInfo {
                call_counts: HashMap::new(),
                execution_times: HashMap::new(),
                allocations: HashMap::new(),
                hot_spots: Vec::new(),
            },
            start_time: Instant::now(),
        }
    }

    /// Records a function call.
    pub fn record_call(&mut self, function_name: String, duration: Duration) {
        *self.profiling_info.call_counts.entry(function_name.clone()).or_insert(0) += 1;
        *self.profiling_info.execution_times.entry(function_name).or_insert(Duration::from_secs(0)) += duration;
    }

    /// Gets profiling results.  
    pub fn get_results(&self) -> &ProfilingInfo {
        &self.profiling_info
    }
}

impl Default for Profiler {
    fn default() -> Self {
        Self::new()
    }
}