example5_comprehensive.c

/**
 * Example 5: Comprehensive Real-World Usage
 * 
 * Demonstrates profiling a more realistic application with:
 * - Multiple algorithms
 * - Comparative performance analysis
 * - Statistics collection
 */

#include "profiler.h"
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

/* Simulated algorithms */
void bubble_sort(int *arr, int n) {
    PROFILER_FUNCTION();
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void quick_sort_helper(int *arr, int low, int high) {
    if (low < high) {
        int pivot = arr[high];
        int i = low - 1;
        
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        
        int pi = i + 1;
        quick_sort_helper(arr, low, pi - 1);
        quick_sort_helper(arr, pi + 1, high);
    }
}

void quick_sort(int *arr, int n) {
    PROFILER_FUNCTION();
    quick_sort_helper(arr, 0, n - 1);
}

void data_processing_pipeline(int size) {
    PROFILER_FUNCTION();
    
    int *data = malloc(size * sizeof(int));
    
    {
        PROFILER_SCOPE(data_generation);
        for (int i = 0; i < size; i++) {
            data[i] = rand() % 1000;
        }
    }
    
    {
        PROFILER_SCOPE(data_transformation);
        for (int i = 0; i < size; i++) {
            data[i] = data[i] * 2 + 1;
        }
    }
    
    {
        PROFILER_SCOPE(data_filtering);
        int count = 0;
        for (int i = 0; i < size; i++) {
            if (data[i] % 3 == 0) {
                count++;
            }
        }
    }
    
    free(data);
}

void run_performance_comparison(void) {
    const int sizes[] = {100, 500, 1000};
    
    for (int s = 0; s < 3; s++) {
        int size = sizes[s];
        printf("\n--- Array size: %d ---\n", size);
        
        /* Prepare test data */
        int *arr1 = malloc(size * sizeof(int));
        int *arr2 = malloc(size * sizeof(int));
        
        for (int i = 0; i < size; i++) {
            arr1[i] = rand() % 1000;
            arr2[i] = arr1[i];
        }
        
        /* Test bubble sort */
        bubble_sort(arr1, size);
        
        /* Test quick sort */
        quick_sort(arr2, size);
        
        free(arr1);
        free(arr2);
    }
}

int main(void) {
    profiler_init();
    srand(42);
    
    printf("=== Example 5: Real-World Performance Analysis ===\n");
    
    /* Enable logging */
    profiler_set_log_file("performance.log");
    
    /* Run sorting comparison */
    printf("\n### Sorting Algorithm Comparison ###\n");
    run_performance_comparison();
    
    /* Run data processing pipeline */
    printf("\n### Data Processing Pipeline ###\n");
    data_processing_pipeline(5000);
    data_processing_pipeline(10000);
    
    /* Benchmark with statistics */
    printf("\n### Statistics Collection ###\n");
    profiler_stats_t pipeline_stats;
    profiler_stats_init(&pipeline_stats, "pipeline_benchmark");
    
    for (int i = 0; i < 10; i++) {
        profiler_timer_t timer;
        profiler_timer_start(&timer, "pipeline_iteration");
        
        int size = 1000 + (rand() % 500);
        int *data = malloc(size * sizeof(int));
        for (int j = 0; j < size; j++) {
            data[j] = rand() % 1000;
        }
        /* Simple processing */
        for (int j = 0; j < size; j++) {
            data[j] = data[j] * data[j];
        }
        free(data);
        
        profiler_timer_stop(&timer);
        profiler_stats_add(&pipeline_stats, profiler_timer_elapsed_ns(&timer));
    }
    
    printf("\n");
    profiler_stats_print(&pipeline_stats);
    
    printf("\nDetailed logs written to performance.log\n");
    
    profiler_shutdown();
    return 0;
}