kernel.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
 
#include "contur/kernel/i_kernel.h"
 
namespace contur {
 
    class IClock;
    class IMemory;
    class IMMU;
    class IVirtualMemory;
    class ICPU;
    class IExecutionEngine;
    class IScheduler;
    class IDispatcher;
    class ITracer;
    class IFileSystem;
    class IDispatchRuntime;
    class IPageReplacementPolicy;
    class ISchedulingPolicy;
    class SyscallTable;
    class IpcManager;
    class DeviceManager;
    class IIoManager;

    struct KernelDependencies
    {
        std::unique_ptr<IClock> clock;

        std::unique_ptr<IMemory> memory;

        std::unique_ptr<IMMU> mmu;

        std::unique_ptr<IVirtualMemory> virtualMemory;

        std::unique_ptr<ICPU> cpu;

        std::unique_ptr<IExecutionEngine> executionEngine;

        std::unique_ptr<IScheduler> scheduler;

        std::unique_ptr<IDispatcher> dispatcher;

        std::unique_ptr<ITracer> tracer;

        std::unique_ptr<IFileSystem> fileSystem;

        std::unique_ptr<DeviceManager> deviceManager;

        std::unique_ptr<IIoManager> ioManager;

        std::unique_ptr<IpcManager> ipcManager;

        std::unique_ptr<SyscallTable> syscallTable;

        std::unique_ptr<IDispatchRuntime> runtime;

        std::size_t defaultTickBudget = static_cast<std::size_t>(DEFAULT_TIME_SLICE);
    };

    class Kernel final : public IKernel
    {
        public:
        explicit Kernel(KernelDependencies deps);

        ~Kernel() override;

        Kernel(const Kernel &) = delete;

        Kernel &operator=(const Kernel &) = delete;
        Kernel(Kernel &&) noexcept;

        Kernel &operator=(Kernel &&) noexcept;

        [[nodiscard]] Result<ProcessId> createProcess(const ProcessConfig &config) override;

        [[nodiscard]] Result<void> terminateProcess(ProcessId pid) override;

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

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

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

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

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

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

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

        [[nodiscard]] KernelSnapshot snapshot() const override;

        [[nodiscard]] Tick now() const noexcept override;

        [[nodiscard]] bool hasProcess(ProcessId pid) const noexcept override;

        [[nodiscard]] std::size_t processCount() const noexcept override;
 
        private:
        struct Impl;
        std::unique_ptr<Impl> impl_;
    };
 
} // namespace contur