dag_config.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "dag_job.h"
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <string>
 
namespace kcenon::thread
{
    enum class dag_failure_policy
    {
        fail_fast,       
        continue_others, 
        retry,           
        fallback         
    };
 
    [[nodiscard]] inline auto dag_failure_policy_to_string(dag_failure_policy policy) -> std::string
    {
        switch (policy)
        {
            case dag_failure_policy::fail_fast:       return "fail_fast";
            case dag_failure_policy::continue_others: return "continue_others";
            case dag_failure_policy::retry:           return "retry";
            case dag_failure_policy::fallback:        return "fallback";
            default:                                  return "unknown";
        }
    }
 
    struct dag_config
    {
        dag_failure_policy failure_policy{dag_failure_policy::fail_fast};
 
        std::size_t max_retries{0};
 
        std::chrono::milliseconds retry_delay{1000};
 
        bool detect_cycles{true};
 
        bool execute_in_parallel{true};
 
        std::function<void(job_id, dag_job_state, dag_job_state)> state_callback;
 
        std::function<void(job_id, const std::string&)> error_callback;
 
        std::function<void(job_id)> completion_callback;
    };
 
    struct dag_stats
    {
        std::size_t total_jobs{0};       
        std::size_t completed_jobs{0};   
        std::size_t failed_jobs{0};      
        std::size_t pending_jobs{0};     
        std::size_t running_jobs{0};     
        std::size_t skipped_jobs{0};     
        std::size_t cancelled_jobs{0};   
 
        std::chrono::milliseconds total_execution_time{0};    
        std::chrono::milliseconds critical_path_time{0};      
        double parallelism_efficiency{0.0};                    
 
        [[nodiscard]] auto is_complete() const -> bool
        {
            return pending_jobs == 0 && running_jobs == 0;
        }
 
        [[nodiscard]] auto all_succeeded() const -> bool
        {
            return is_complete() && failed_jobs == 0 && cancelled_jobs == 0;
        }
 
        [[nodiscard]] auto success_rate() const -> double
        {
            if (total_jobs == 0) return 0.0;
            return static_cast<double>(completed_jobs) / static_cast<double>(total_jobs);
        }
    };
 
} // namespace kcenon::thread