operation_pipeline_executor.h

Go to the documentation of this file.

 
#pragma once
 
#include "pipeline/interfaces/i_pipeline_executor.h"
#include "pipeline/interfaces/i_halide_pipeline_executor.h"
#include "operations/operation_descriptor.h"
#include "operations/operation_factory.h"
#include "common/types/memory_type.h"
 
#include <vector>
#include <unordered_map>
 
namespace CaptureMoment::Core {
 
namespace Pipeline {
 
class OperationPipelineExecutor : public IPipelineExecutor, public IHalidePipelineExecutor {
public:
    OperationPipelineExecutor();
 
    virtual ~OperationPipelineExecutor() = default;
 
    void updatePipeline(std::vector<Operations::OperationDescriptor> operations);
 
    void init(
        std::vector<Operations::OperationDescriptor>&& operations,
        const Operations::OperationFactory& factory
    );
 
    void updateRuntimeParams(std::vector<Operations::OperationDescriptor>&& operations);
 
protected: 
    virtual void applyScheduling(Halide::Func& pipeline, Halide::Var& x, Halide::Var& y, Halide::Var& c) const = 0;
    
    [[nodiscard]] bool executeOnHalideBuffer(Halide::Buffer<float>& input_buffer, Halide::Buffer<float>& output_buffer) override;
 
    [[nodiscard]] Halide::Func applyOperations(const Halide::Func& input, const Halide::Var& x, const Halide::Var& y, const Halide::Var& c);
 
    virtual void buildOperationChain() = 0;
 
    Halide::Pipeline m_pipeline;
 
    bool m_chain_built{false};
 
private:
    std::vector<Operations::OperationDescriptor> m_operations;
 
    const Operations::OperationFactory* m_factory;
 
    std::unordered_map<uint64_t, Halide::Param<float>> m_pipeline_params;
};
} // namespace Pipeline
} // namespace CaptureMoment::Core