i_kernel.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include "contur/core/error.h"
#include "contur/core/types.h"
 
#include "contur/arch/block.h"
#include "contur/process/priority.h"
#include "contur/process/state.h"
#include "contur/syscall/syscall_ids.h"
 
namespace contur {
 
    class ISyncPrimitive;
    class ProcessImage;

    struct ProcessConfig
    {
        ProcessId id = INVALID_PID;

        std::string name;

        std::vector<Block> code;

        Priority priority{};

        Tick arrivalTime = 0;

        std::string nativePath;
    };

    struct KernelProcessSnapshot
    {
        ProcessId id = INVALID_PID;

        std::string name;

        ProcessState state = ProcessState::New;

        PriorityLevel basePriority = PriorityLevel::Normal;

        PriorityLevel effectivePriority = PriorityLevel::Normal;

        std::int32_t nice = NICE_DEFAULT;

        Tick cpuTime = 0;

        std::optional<std::size_t> laneIndex;
    };

    struct KernelSnapshot
    {
        Tick currentTick = 0;

        std::size_t processCount = 0;

        std::size_t readyCount = 0;

        std::size_t blockedCount = 0;

        std::vector<ProcessId> runningPids;

        std::vector<ProcessId> readyQueue;

        std::vector<ProcessId> blockedQueue;

        std::vector<std::vector<ProcessId>> perLaneReadyQueues;

        std::string policyName;

        std::vector<KernelProcessSnapshot> processes;

        std::size_t totalVirtualSlots = 0;

        std::size_t freeVirtualSlots = 0;

        std::optional<std::size_t> totalFrames;

        std::optional<std::size_t> freeFrames;

        std::vector<std::optional<ProcessId>> frameOwners;
    };

    using SyscallHandlerFn =
        std::function<Result<RegisterValue>(std::span<const RegisterValue> args, ProcessImage &caller)>;

    class IKernel
    {
        public:
        virtual ~IKernel() = default;

        [[nodiscard]] virtual Result<ProcessId> createProcess(const ProcessConfig &config) = 0;

        [[nodiscard]] virtual Result<void> terminateProcess(ProcessId pid) = 0;

        [[nodiscard]] virtual Result<void> tick(std::size_t tickBudget = 0) = 0;

        [[nodiscard]] virtual Result<void> runForTicks(std::size_t cycles, std::size_t tickBudget = 0) = 0;

        [[nodiscard]] virtual Result<RegisterValue>
        syscall(ProcessId pid, SyscallId id, std::span<const RegisterValue> args) = 0;

        [[nodiscard]] virtual Result<void> registerSyscallHandler(SyscallId id, SyscallHandlerFn handler) = 0;

        [[nodiscard]] virtual Result<void>
        registerSyncPrimitive(const std::string &name, std::unique_ptr<ISyncPrimitive> primitive) = 0;

        [[nodiscard]] virtual Result<void> enterCritical(ProcessId pid, std::string_view primitiveName) = 0;

        [[nodiscard]] virtual Result<void> leaveCritical(ProcessId pid, std::string_view primitiveName) = 0;

        [[nodiscard]] virtual KernelSnapshot snapshot() const = 0;

        [[nodiscard]] virtual Tick now() const noexcept = 0;

        [[nodiscard]] virtual bool hasProcess(ProcessId pid) const noexcept = 0;

        [[nodiscard]] virtual std::size_t processCount() const noexcept = 0;
    };
 
} // namespace contur