buffer.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/sharedptr.h>
#include <promeki/memspace.h>
#include <promeki/memdomain.h>
#include <promeki/buffermapflags.h>
#include <promeki/bufferimpl.h>
#include <promeki/bufferrequest.h>
#include <promeki/bufferfactory.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class String;
 
class Buffer {
        public:
                using List = ::promeki::List<Buffer>;
 
                static size_t getPageSize();
 
                static const size_t DefaultAlign;
 
                Buffer() = default;
 
                Buffer(size_t sz, size_t an = DefaultAlign, const MemSpace &ms = MemSpace::Default)
                    : _d(makeBufferImpl(ms, sz, an)) {}
 
                static Buffer wrapHost(void *p, size_t sz, size_t an = 0, const MemSpace &ms = MemSpace::Default);
 
                static Buffer fromImpl(BufferImpl *impl) {
                        Buffer b;
                        if (impl != nullptr) b._d = BufferImplPtr::takeOwnership(impl);
                        return b;
                }
 
                static Result<Buffer> fromHex(const String &hex);
 
                String toHex(const String &sep) const;
 
                String toHex() const;
 
                bool isValid() const { return _d.isValid() && _d->allocSize() > 0; }
 
                void *data() {
                        if (!_d.isValid()) return nullptr;
                        void *base = _d->mappedHostData();
                        if (base == nullptr) return nullptr;
                        return static_cast<uint8_t *>(base) + _d->shift();
                }
 
                const void *data() const {
                        if (!_d.isValid()) return nullptr;
                        const void *base = _d->mappedHostData();
                        if (base == nullptr) return nullptr;
                        return static_cast<const uint8_t *>(base) + _d->shift();
                }
 
                void *odata() {
                        if (!_d.isValid()) return nullptr;
                        return _d->mappedHostData();
                }
 
                const void *odata() const {
                        if (!_d.isValid()) return nullptr;
                        return _d->mappedHostData();
                }
 
                size_t size() const { return _d.isValid() ? _d->logicalSize() : 0; }
 
                void setSize(size_t s) const {
                        assert(s <= availSize());
                        if (_d.isValid()) _d->setLogicalSize(s);
                        // setLogicalSize is a const method on BufferImpl
                        // (mutates a `mutable` member), so `_d->` const
                        // operator-> reaches it without modify().
                }
 
                size_t availSize() const {
                        if (!_d.isValid()) return 0;
                        size_t total = _d->allocSize();
                        size_t shift = _d->shift();
                        return shift > total ? 0 : total - shift;
                }
 
                size_t allocSize() const { return _d.isValid() ? _d->allocSize() : 0; }
 
                size_t align() const { return _d.isValid() ? _d->align() : 0; }
 
                MemSpace memSpace() const { return _d.isValid() ? _d->memSpace() : MemSpace(MemSpace::System); }
 
                void shiftData(size_t bytes) {
                        assert(_d.isValid());
                        assert(bytes <= _d->allocSize());
                        _d.modify()->setShift(bytes);
                }
 
                size_t shift() const { return _d.isValid() ? _d->shift() : 0; }
 
                // ---- Mapping ----
 
                bool isMapped(MemDomain domain = MemDomain::Host) const {
                        return _d.isValid() && _d->isMapped(domain);
                }
 
                bool isHostAccessible() const { return isMapped(MemDomain::Host); }
 
                BufferRequest mapAcquire(MemDomain domain = MemDomain::Host, MapFlags flags = MapFlags::Read) {
                        if (!_d.isValid()) return BufferRequest::resolved(Error::Invalid);
                        return _d.modify()->mapAcquire(domain, flags);
                }
 
                BufferRequest mapRelease(MemDomain domain = MemDomain::Host) {
                        if (!_d.isValid()) return BufferRequest::resolved(Error::Invalid);
                        return _d.modify()->mapRelease(domain);
                }
 
                // ---- Mutation ----
 
                Error fill(char value) const {
                        if (!_d.isValid()) return Error::Invalid;
                        return _d.modify()->fill(value, _d->shift(), availSize());
                }
 
                Error copyFrom(const void *src, size_t bytes, size_t offset = 0) const;
 
                BufferRequest copyTo(Buffer &dst, size_t bytes, size_t srcOffset = 0, size_t dstOffset = 0) const;
 
                // ---- Detach ----
 
                void ensureExclusive() {
                        if (!_d.isValid()) return;
                        if (_d.referenceCount() < 2) return;
                        if (!_d->canClone()) return;
                        _d.detach();
                }
 
                Error ensureExclusiveError() {
                        if (!_d.isValid()) return Error::Invalid;
                        if (_d.referenceCount() < 2) return Error::Ok;
                        if (!_d->canClone()) return Error::NotSupported;
                        _d.detach();
                        return Error::Ok;
                }
 
                bool isExclusive() const { return _d.isValid() && _d.referenceCount() < 2; }
 
                bool isShared() const { return _d.isValid() && _d.referenceCount() >= 2; }
 
                [[nodiscard]] Error seal() const {
                        if (!_d.isValid()) return Error::Invalid;
                        return _d->seal();
                }
 
                size_t residentBytes() const {
                        return _d.isValid() ? _d->residentBytes() : 0;
                }
 
                bool isCowBacked() const {
                        return _d.isValid() && _d->isCowBacked();
                }
 
                const BufferImplPtr &impl() const { return _d; }
 
                bool operator==(const Buffer &o) const;
 
                bool operator!=(const Buffer &o) const { return !(*this == o); }
 
                explicit operator bool() const { return _d.isValid(); }
 
        private:
                // mutable so const-on-method mutators (setSize, fill,
                // copyFrom) can call _d.modify() to reach the
                // BufferImpl's non-const interface without
                // const_cast.  The Buffer wrapper's own identity (the
                // impl pointer) is never reassigned through a const
                // path; only the pointed-to BufferImpl is mutated.
                mutable BufferImplPtr _d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE