bufferimpl.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <cstdint>
#include <utility>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/error.h>
#include <promeki/function.h>
#include <promeki/mutex.h>
#include <promeki/map.h>
#include <promeki/memspace.h>
#include <promeki/memdomain.h>
#include <promeki/buffermapflags.h>
#include <promeki/bufferrequest.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class BufferImpl {
        public:
                PROMEKI_SHARED_BASE(BufferImpl)
 
                
                using ReleaseCallback = Function<void()>;
 
                BufferImpl() = default;
 
                virtual ~BufferImpl() {
                        if (_onRelease) _onRelease();
                }
 
                BufferImpl(const BufferImpl &) = default;
                BufferImpl &operator=(const BufferImpl &) = default;
 
                // ---- Identity / sizing ----
 
                virtual MemSpace memSpace() const = 0;
 
                virtual size_t allocSize() const = 0;
 
                virtual size_t align() const = 0;
 
                // ---- Map state ----
 
                bool isMapped(MemDomain domain) const { return mapRefcount(domain.id()) > 0; }
 
                virtual void *mappedHostData() const = 0;
 
                virtual BufferRequest mapAcquire(MemDomain domain, MapFlags flags) = 0;
 
                virtual BufferRequest mapRelease(MemDomain domain) = 0;
 
                // ---- Mutation ----
 
                virtual Error fill(char value, size_t offset, size_t bytes) = 0;
 
                virtual Error copyFromHost(const void *src, size_t bytes, size_t offset) = 0;
 
                // ---- Logical size + data shift (shared across handles) ----
 
                size_t logicalSize() const { return _logicalSize; }
 
                void setLogicalSize(size_t s) const { _logicalSize = s; }
 
                size_t shift() const { return _shift; }
 
                void setShift(size_t s) {
                        _shift = s;
                        _logicalSize = 0;
                }
 
                // ---- Cloning ----
 
                virtual bool canClone() const { return true; }
 
                // ---- Producer→post-producer transition (seal) ----
 
                virtual Error seal() const { return Error::Ok; }
 
                virtual size_t residentBytes() const { return allocSize(); }
 
                virtual bool isCowBacked() const { return false; }
 
                // ---- Release notification ----
 
                void setReleaseCallback(ReleaseCallback cb) { _onRelease = std::move(cb); }
 
        protected:
                int incrementMapRefcount(MemDomain::ID domain) {
                        Mutex::Locker lock(_mapMutex);
                        auto          it = _mapRefcounts.find(domain);
                        if (it == _mapRefcounts.end()) {
                                _mapRefcounts.insert(domain, 1);
                                return 1;
                        }
                        return ++it->second;
                }
 
                int decrementMapRefcount(MemDomain::ID domain) {
                        Mutex::Locker lock(_mapMutex);
                        auto          it = _mapRefcounts.find(domain);
                        if (it == _mapRefcounts.end()) return -1;
                        if (it->second == 0) return -1;
                        return --it->second;
                }
 
                int mapRefcount(MemDomain::ID domain) const {
                        Mutex::Locker lock(_mapMutex);
                        auto          it = _mapRefcounts.find(domain);
                        return (it == _mapRefcounts.end()) ? 0 : it->second;
                }
 
                void seedMapRefcount(MemDomain::ID domain, int count) { _mapRefcounts.insert(domain, count); }
 
                mutable size_t _logicalSize = 0;
                size_t         _shift = 0;
 
        private:
                mutable Mutex          _mapMutex;
                Map<MemDomain::ID, int> _mapRefcounts;
                ReleaseCallback         _onRelease;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE