processor_restore.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/format/plugin_descriptor.hpp>
 
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
namespace pulp::format {
class ProcessorNodeInstance;
}
 
namespace pulp::host {
 
struct ProcessorTypeKey {
    std::string type_id;
    int type_version = 1;
    friend bool operator==(const ProcessorTypeKey&, const ProcessorTypeKey&) = default;
};
 
enum class ProcessorRestoreCode {
    Restored,
    InvalidDescriptor,
    DuplicateProcessorType,
    InvalidRecord,
    StateLimitExceeded,
    UnknownProcessorType,
    ProcessorTypeDisallowed,
    UnsupportedVersion,
    ProcessorConstructionFailed,
    ProcessorInstanceNotFresh,
    ProcessorPortMismatch,
    ProcessorCapabilityMismatch,
    ProcessorStateRestoreFailed,
};

const char* processor_restore_code_name(ProcessorRestoreCode code) noexcept;

struct ProcessorRestoreDescriptor {
    ProcessorTypeKey type;
    int state_schema_version = 1;
    int input_channels = 0;
    int output_channels = 0;
    format::NodeCapabilities capabilities;
    std::function<std::shared_ptr<format::ProcessorNodeInstance>()> create;
};

struct ProcessorRestoreRecord {
    std::uint32_t node_id = 0;
    ProcessorTypeKey type;
    int state_schema_version = 1;
    int input_channels = 0;
    int output_channels = 0;
    std::span<const std::uint8_t> parameters;
    std::span<const std::uint8_t> custom;
};
 
struct RestoredProcessor {
    std::uint32_t node_id = 0;
    std::shared_ptr<format::ProcessorNodeInstance> instance;
};
 
struct ProcessorRestoreResult {
    ProcessorRestoreCode code = ProcessorRestoreCode::InvalidRecord;
    std::uint32_t node_id = 0;
    ProcessorTypeKey type;
    std::vector<RestoredProcessor> processors;
    bool ok() const noexcept {
        return code == ProcessorRestoreCode::Restored;
    }
};

class ProcessorRestoreRegistry {
  public:
    static constexpr std::size_t max_nodes = 4096;
    static constexpr std::size_t max_state_part_bytes = 8 * 1024 * 1024;
    static constexpr std::size_t max_total_state_bytes = 32 * 1024 * 1024;
 
    ProcessorRestoreCode register_type(ProcessorRestoreDescriptor descriptor);

    ProcessorRestoreResult restore_batch(std::span<const ProcessorRestoreRecord> records,
                                         std::span<const ProcessorTypeKey> allowlist) const;
 
  private:
    std::map<std::pair<std::string, int>, ProcessorRestoreDescriptor> descriptors_;
};
 
} // namespace pulp::host