Micro-Benchmarking in Python: Measuring Performance with Custom Counters

1. PMU Counters Benchmarking: This module utilizes the perf library to measure CPU PMU counters. These counters provide valuable insights into the behavior of CPU caches, branch mispredictions, and other low-level performance metrics.

2. Memory Allocation Benchmarking: In this module, the pyjemalloc library is used to measure memory allocations with the jemalloc memory allocator. Jemalloc is known for its efficiency and scalability, making it a good candidate for memory allocation benchmarking.

3. Custom Measurement Benchmarking: The custom measurement module allows us to measure custom computations in the code. In this example, we demonstrate how to measure the number of hash collisions using a custom hashing algorithm.

1. Installation: Clone the repository and install the required dependencies using pip by running the following commands:

git clone <https://github.com/athy125/PyPerfMonitor.git>
cd PyPerfMonitor
python -m venv venv
source venv/bin/activate   # On Windows, use `venv\\Scripts\\activate`
pip install -r requirements.txt

1. PMU Counters Benchmarking: In the pmu_benchmark.py module, you can specify the events to measure and the function you want to benchmark. For example:

from pmu_benchmark import PMUBenchmark

def example_function():
    for i in range(100000):
        _ = i * i

if __name__ == "__main__":
    pmu_benchmark = PMUBenchmark(runs=5, number=1000)
    pmu_events = [
        "cpu/cache-misses/",
        "cpu/branch-misses/",
    ]
    pmu_benchmark.measure_pmu_counters(example_function, events=pmu_events)

1. Memory Allocation Benchmarking: In the memory_benchmark.py module, you can measure memory allocations with jemalloc by specifying the allocation size and the number of runs. For example:

from memory_benchmark import MemoryBenchmark

if __name__ == "__main__":
    memory_benchmark = MemoryBenchmark(runs=5, number=1000)
    allocation_size = 1024
    memory_benchmark.measure_memory_allocation(allocation_size)

1. Custom Measurement Benchmarking: In the custom_benchmark.py module, you can define custom computations. In this example, we measure the number of hash collisions using a simple hashing algorithm. For example:

def custom_hash_collision():
    collisions = 0
    hash_set = set()
    
    # Generate 10000 random strings and calculate their SHA-256 hash values
    for i in range(10000):
        data = ''.join(random.choices(string.ascii_letters + string.digits, k=10)).encode()
        hash_value = hashlib.sha256(data).hexdigest()
        
        # Check for hash collisions
        if hash_value in hash_set:
            collisions += 1
        hash_set.add(hash_value)

    print(f"Number of hash collisions: {collisions}")