benchmark_tests.cpp

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include <benchmark/benchmark.h>
#include <memory>
#include <chrono>
#include <thread>
#include <future>
#include <vector>
#include <algorithm>
 
#include "database/database_manager.h"
#include "database/database_types.h"
#include "database/core/database_context.h"
#include "database/orm/entity.h"
#include "database/monitoring/performance_monitor.h"
#include "database/security/secure_connection.h"
#include "database/async/async_operations.h"
 
using namespace database;
using namespace database::orm;
using namespace database::monitoring;
using namespace database::security;
using namespace database::async;
 
// Benchmark database manager operations
static void BM_DatabaseManagerCreation(benchmark::State& state) {
    for (auto _ : state) {
        auto context = std::make_shared<database_context>();
        auto db = std::make_shared<database_manager>(context);
        benchmark::DoNotOptimize(db.get());
    }
}
BENCHMARK(BM_DatabaseManagerCreation);
 
static void BM_DatabaseTypeSettings(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto db = std::make_shared<database_manager>(context);
    for (auto _ : state) {
        db->set_mode(database_types::postgres);
        auto type = db->database_type();
        benchmark::DoNotOptimize(type);
    }
}
BENCHMARK(BM_DatabaseTypeSettings);
 
static void BM_QueryCreation(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto db = std::make_shared<database_manager>(context);
    db->set_mode(database_types::postgres);
 
    for (auto _ : state) {
        auto result = db->create_query_result("SELECT 1");
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_QueryCreation);
 
static void BM_SelectQuery(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto db = std::make_shared<database_manager>(context);
    db->set_mode(database_types::postgres);
 
    for (auto _ : state) {
        auto result = db->select_query_result("SELECT 1");
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_SelectQuery);
 
// Mock entity for ORM performance tests (conceptual)
class BenchmarkUser {
public:
    int64_t id = 0;
    std::string username;
    std::string email;
    bool is_active = true;
 
    BenchmarkUser() = default;
 
    // Mock ORM operations
    std::string table_name() const { return "benchmark_users"; }
    bool save() { return true; }
    bool load() { return true; }
};
 
// Phase 4: ORM Framework Benchmarks
static void BM_ORMEntityCreation(benchmark::State& state) {
    for (auto _ : state) {
        BenchmarkUser user;
        user.username = "benchmark_user";
        user.email = "benchmark@test.com";
        benchmark::DoNotOptimize(user);
    }
}
BENCHMARK(BM_ORMEntityCreation);
 
static void BM_ORMEntityMetadataAccess(benchmark::State& state) {
    BenchmarkUser user;
    for (auto _ : state) {
        // Mock metadata access
        std::string table = user.table_name();
        size_t field_count = 4; // id, username, email, is_active
        benchmark::DoNotOptimize(table);
        benchmark::DoNotOptimize(field_count);
    }
}
BENCHMARK(BM_ORMEntityMetadataAccess);
 
static void BM_ORMEntityFieldAccess(benchmark::State& state) {
    BenchmarkUser user;
    user.username = "test_user";
    user.email = "test@example.com";
 
    for (auto _ : state) {
        // Mock field access (direct access, not through ORM fields)
        auto username = user.username;
        auto email = user.email;
        auto active = user.is_active;
        benchmark::DoNotOptimize(username);
        benchmark::DoNotOptimize(email);
        benchmark::DoNotOptimize(active);
    }
}
BENCHMARK(BM_ORMEntityFieldAccess);
 
static void BM_ORMEntityManager(benchmark::State& state) {
    // Mock entity manager operations
    for (auto _ : state) {
        // Simulate metadata retrieval
        std::string entity_name = "BenchmarkUser";
        size_t field_count = 4;
        benchmark::DoNotOptimize(entity_name);
        benchmark::DoNotOptimize(field_count);
    }
}
BENCHMARK(BM_ORMEntityManager);
 
// Phase 4: Performance Monitoring Benchmarks
static void BM_PerformanceMonitorConfiguration(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto monitor = context->get_performance_monitor();
 
    for (auto _ : state) {
        // Mock configuration using actual API
        monitor->set_metrics_retention_period(std::chrono::minutes(60));
        monitor->set_alert_thresholds(0.05, std::chrono::microseconds(1000000));
        benchmark::DoNotOptimize(monitor.get());
    }
}
BENCHMARK(BM_PerformanceMonitorConfiguration);
 
static void BM_QueryMetricsRecording(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto monitor = context->get_performance_monitor();
    monitor->set_metrics_retention_period(std::chrono::minutes(60));
 
    query_metrics metrics;
    metrics.query_hash = "SELECT_benchmark";
    metrics.execution_time = std::chrono::microseconds(10000);
    metrics.success = true;
    metrics.rows_affected = 100;
    metrics.db_type = database_types::postgres;
    metrics.start_time = std::chrono::steady_clock::now();
    metrics.end_time = metrics.start_time + metrics.execution_time;
 
    for (auto _ : state) {
        monitor->record_query_metrics(metrics);
    }
}
BENCHMARK(BM_QueryMetricsRecording);
 
static void BM_ConnectionMetricsRecording(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto monitor = context->get_performance_monitor();
    monitor->set_metrics_retention_period(std::chrono::minutes(60));
 
    connection_metrics metrics;
    metrics.total_connections.store(20);
    metrics.active_connections.store(10);
    metrics.idle_connections.store(10);
 
    for (auto _ : state) {
        monitor->record_connection_metrics(database_types::postgres, metrics);
    }
}
BENCHMARK(BM_ConnectionMetricsRecording);
 
static void BM_SystemMetricsAccess(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto monitor = context->get_performance_monitor();
 
    for (auto _ : state) {
        // Mock system metrics access
        double cpu_usage = 50.0;
        double memory_usage = 75.0;
        benchmark::DoNotOptimize(cpu_usage);
        benchmark::DoNotOptimize(memory_usage);
    }
}
BENCHMARK(BM_SystemMetricsAccess);
 
// Phase 4: Security Framework Benchmarks (Conceptual)
static void BM_SecurityConfigurationOverhead(benchmark::State& state) {
    // Mock security configuration benchmark
    struct MockSecurityConfig {
        bool tls_enabled = true;
        std::string cipher_suite = "AES256-GCM-SHA384";
        std::vector<std::string> permissions;
    };
 
    for (auto _ : state) {
        MockSecurityConfig config;
        config.permissions = {"read", "write", "admin"};
 
        // Simulate permission check overhead
        bool has_permission = std::find(config.permissions.begin(),
                                       config.permissions.end(), "read") != config.permissions.end();
        benchmark::DoNotOptimize(has_permission);
    }
}
BENCHMARK(BM_SecurityConfigurationOverhead);
 
static void BM_SecureConnectionHandshake(benchmark::State& state) {
    // Simulate TLS handshake overhead
    for (auto _ : state) {
        // Mock TLS handshake simulation
        std::this_thread::sleep_for(std::chrono::microseconds(10));
        bool handshake_success = true;
        benchmark::DoNotOptimize(handshake_success);
    }
}
BENCHMARK(BM_SecureConnectionHandshake);
 
static void BM_CredentialValidation(benchmark::State& state) {
    // Mock credential validation benchmark
    std::string username = "test_user";
    std::string password_hash = "hashed_password_123456789";
 
    for (auto _ : state) {
        // Simulate password hash verification
        bool valid = (username.length() > 0 && password_hash.length() > 10);
        benchmark::DoNotOptimize(valid);
    }
}
BENCHMARK(BM_CredentialValidation);
 
// Phase 4: Asynchronous Operations Benchmarks
static void BM_AsyncExecutorCreation(benchmark::State& state) {
    for (auto _ : state) {
        // Mock async executor creation
        std::thread::hardware_concurrency(); // Simulate executor setup
        bool executor_ready = true;
        benchmark::DoNotOptimize(executor_ready);
    }
}
BENCHMARK(BM_AsyncExecutorCreation);
 
static void BM_AsyncOperationSubmission(benchmark::State& state) {
    // Mock async operation using std::async
    for (auto _ : state) {
        auto future = std::async(std::launch::async, []() -> int {
            return 42;
        });
        int result = future.get();
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_AsyncOperationSubmission);
 
static void BM_AsyncConnectionPoolAccess(benchmark::State& state) {
    // Mock async connection pool access
    struct MockResult { bool success = true; };
 
    for (auto _ : state) {
        auto future = std::async(std::launch::async, []() -> MockResult {
            std::this_thread::sleep_for(std::chrono::microseconds(100));
            return MockResult{true};
        });
        auto result = future.get();
        benchmark::DoNotOptimize(result.success);
    }
}
BENCHMARK(BM_AsyncConnectionPoolAccess);
 
// Concurrent operations benchmark
static void BM_ConcurrentAsyncOperations(benchmark::State& state) {
    // Mock concurrent async operations using std::async
    for (auto _ : state) {
        std::vector<std::future<int>> futures;
        const int num_operations = state.range(0);
 
        // Submit concurrent operations
        for (int i = 0; i < num_operations; ++i) {
            auto future = std::async(std::launch::async, [i]() -> int {
                // Simulate small amount of work
                std::this_thread::sleep_for(std::chrono::microseconds(100));
                return i;
            });
            futures.push_back(std::move(future));
        }
 
        // Wait for all operations
        for (auto& future : futures) {
            int result = future.get();
            benchmark::DoNotOptimize(result);
        }
    }
}
BENCHMARK(BM_ConcurrentAsyncOperations)->Arg(10)->Arg(50)->Arg(100);
 
// Connection Pool Benchmarks removed in Phase 4.3 - pooling moved to server-side ProxyMode
 
// Phase 4: Query Builder Benchmarks
static void BM_SQLQueryBuilderCreation(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto db = std::make_shared<database_manager>(context);
 
    for (auto _ : state) {
        auto builder = db->create_query_builder(database_types::postgres);
        benchmark::DoNotOptimize(&builder);
    }
}
BENCHMARK(BM_SQLQueryBuilderCreation);
 
static void BM_SQLQueryBuilding(benchmark::State& state) {
    auto context = std::make_shared<database_context>();
    auto db = std::make_shared<database_manager>(context);
    auto builder = db->create_query_builder(database_types::postgres);
 
    for (auto _ : state) {
        builder.select({"id", "name", "email"})
               .from("users")
               .where("active", "=", core::database_value{true})
               .order_by("name");
        benchmark::DoNotOptimize(&builder);
    }
}
BENCHMARK(BM_SQLQueryBuilding);
 
// Comprehensive system benchmark
static void BM_IntegratedSystemPerformance(benchmark::State& state) {
    // Setup all Phase 4 systems
    auto context = std::make_shared<database_context>();
    auto db = std::make_shared<database_manager>(context);
    auto monitor = context->get_performance_monitor();
 
    // Configure systems using actual API
    monitor->set_metrics_retention_period(std::chrono::minutes(60));
    monitor->set_alert_thresholds(0.05, std::chrono::microseconds(1000000));
 
    // Mock security setup
    struct MockSecurity {
        bool has_permission(const std::string&, const std::string&) { return true; }
    };
    MockSecurity security;
 
    for (auto _ : state) {
        // Integrated workflow: Security + Monitoring + Async + ORM
        auto future = std::async(std::launch::async, [&]() -> bool {
            // Check permissions
            bool can_access = security.has_permission("test_user", "data.select");
 
            // Create entity
            BenchmarkUser user;
            user.username = "integrated_user";
            user.email = "integrated@test.com";
 
            // Record performance metrics using actual API
            query_metrics metrics;
            metrics.query_hash = "INTEGRATED";
            metrics.execution_time = std::chrono::microseconds(1000);
            metrics.success = true;
            metrics.rows_affected = 1;
            metrics.db_type = database_types::postgres;
            metrics.start_time = std::chrono::steady_clock::now();
            metrics.end_time = metrics.start_time + metrics.execution_time;
            monitor->record_query_metrics(metrics);
 
            return can_access && user.is_active;
        });
 
        bool result = future.get();
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_IntegratedSystemPerformance);
 
BENCHMARK_MAIN();