hostbufferimpl.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstring>
#include <promeki/namespace.h>
#include <promeki/bufferimpl.h>
#include <promeki/buffercommand.h>
#include <promeki/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class HostMappedBufferImpl : public BufferImpl {
        public:
                PROMEKI_SHARED_DERIVED(HostMappedBufferImpl)
 
                
                HostMappedBufferImpl(const MemSpace &ms, void *hostPtr, size_t allocSize, size_t align)
                    : _hostPtr(hostPtr), _allocSize(allocSize), _align(align), _memSpace(ms) {
                        seedMapRefcount(MemDomain::Host, 1);
                }
 
                MemSpace memSpace() const override { return _memSpace; }
                size_t   allocSize() const override { return _allocSize; }
                size_t   align() const override { return _align; }
 
                void *mappedHostData() const override { return _hostPtr; }
 
                BufferRequest mapAcquire(MemDomain domain, MapFlags flags) override {
                        (void)flags;
                        if (domain.id() != MemDomain::Host) return resolvedMap(domain, flags, nullptr, Error::NotSupported);
                        incrementMapRefcount(MemDomain::Host);
                        return resolvedMap(domain, flags, _hostPtr, Error::Ok);
                }
 
                BufferRequest mapRelease(MemDomain domain) override {
                        if (domain.id() != MemDomain::Host) return resolvedUnmap(domain, Error::Invalid);
                        int newCount = decrementMapRefcount(MemDomain::Host);
                        return resolvedUnmap(domain, newCount < 0 ? Error::Invalid : Error::Ok);
                }
 
                Error fill(char value, size_t offset, size_t bytes) override {
                        if (_hostPtr == nullptr) return Error::Invalid;
                        std::memset(static_cast<uint8_t *>(_hostPtr) + offset, value, bytes);
                        return Error::Ok;
                }
 
                Error copyFromHost(const void *src, size_t bytes, size_t offset) override {
                        if (_hostPtr == nullptr) return Error::Invalid;
                        std::memcpy(static_cast<uint8_t *>(_hostPtr) + offset, src, bytes);
                        return Error::Ok;
                }
 
        protected:
                static BufferRequest resolvedMap(MemDomain target, MapFlags flags, void *hostPtr, Error result) {
                        auto *cmd = new BufferMapCommand();
                        cmd->target = target;
                        cmd->flags = flags;
                        cmd->hostPtr = hostPtr;
                        cmd->result = result;
                        return BufferRequest::resolved(BufferCommand::Ptr::takeOwnership(cmd));
                }
 
                static BufferRequest resolvedUnmap(MemDomain target, Error result) {
                        auto *cmd = new BufferUnmapCommand();
                        cmd->target = target;
                        cmd->result = result;
                        return BufferRequest::resolved(BufferCommand::Ptr::takeOwnership(cmd));
                }
 
                // _hostPtr is mutable because backends with a producer→post-producer
                // transition (e.g. MemfdBufferImpl::seal()) need to swap the pointer
                // through a const seal API.  The Buffer wrapper always re-fetches
                // through mappedHostData(); no caller caches across the swap.
                mutable void    *_hostPtr = nullptr;
                size_t           _allocSize = 0;
                size_t           _align = 0;
                MemSpace         _memSpace;
};
 
class HostBufferImpl : public HostMappedBufferImpl {
        public:
                HostBufferImpl(const MemSpace &ms, size_t bytes, size_t align);
 
                ~HostBufferImpl() override;
 
                HostBufferImpl *_promeki_clone() const override;
};
 
class HostSecureBufferImpl : public HostMappedBufferImpl {
        public:
                HostSecureBufferImpl(const MemSpace &ms, size_t bytes, size_t align);
 
                ~HostSecureBufferImpl() override;
 
                HostSecureBufferImpl *_promeki_clone() const override;
};
 
class WrappedHostBufferImpl : public HostMappedBufferImpl {
        public:
                PROMEKI_SHARED_DERIVED(WrappedHostBufferImpl)
 
                
                WrappedHostBufferImpl(const MemSpace &ms, void *ptr, size_t bytes, size_t align)
                    : HostMappedBufferImpl(ms, ptr, bytes, align) {}
 
                ~WrappedHostBufferImpl() override = default;
 
                bool canClone() const override { return false; }
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE