job.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024 XCENA Inc.
 
#pragma once
#include <cstddef>
#include <cstdint>
#include <functional>
#include <vector>
 
#include "pxl/memory.hpp"
#include "pxl/type.hpp"
 
namespace pxl
{
class Module;
class Function;
class Context;
class Map;
 
class Job
{
public:
    using AsyncCallback = std::function<void(Job* job, void* arg)>;
 
    Job(const Job&) = delete;
 
    Job& operator=(const Job&) = delete;
 
    virtual Result load(const char* muBinaryPath) = 0;
 
    virtual Result load(const pxl::Module* module) = 0;
 
    virtual bool isLoaded() const = 0;
 
    virtual const std::vector<uint32_t> subIdList() const = 0;
 
    virtual Map* buildMap(const char* muFuncName, const uint32_t taskCount) = 0;
 
    virtual Map* buildMap(const pxl::Function* muFunc, const uint32_t taskCount) = 0;
 
    virtual Map* buildMap(const uint32_t taskCount) = 0;
 
    virtual void destroyMap(Map* map) = 0;
 
    virtual uint64_t id() const = 0;
 
    virtual uint32_t deviceId() const = 0;
 
    // reload() is declared at the tail of the interface, not beside load():
    // new virtuals must append to the vtable end to preserve ABI for callers
    // linked against an earlier header.
 
    virtual Result reload(const char* muBinaryPath) = 0;
 
    virtual Result reload(const pxl::Module* module) = 0;
 
    virtual void* allocateMemory(size_t size, AllocFlag flag = AllocFlag::None) = 0;
 
    template <typename T>
    T* allocateMemory(size_t count, AllocFlag flag = AllocFlag::None)
    {
        if (count > 0 && count > SIZE_MAX / sizeof(T))
        {
            return nullptr;
        }
        return static_cast<T*>(allocateMemory(count * sizeof(T), flag));
    }
 
    virtual Result remapMemory(void* ptr, uintptr_t virtualAddr) = 0;
 
    virtual Result unmapMemory(uintptr_t virtualAddr) = 0;
 
protected:
    Job() = default;
    virtual ~Job() = default;
};
 
}  // namespace pxl