memspace.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/atomic.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/list.h>
#include <promeki/error.h>
#include <promeki/memdomain.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
struct MemAllocation;
 
class MemSpace {
        public:
                PROMEKI_DATATYPE(MemSpace, DataTypeMemSpace, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<MemSpace> readFromStream(DataStream &s);
 
                enum ID {
                        System = 0,       
                        SystemSecure = 1, 
                        CudaDevice =
                                2, 
                        CudaHost =
                                3, 
                        SystemCow =
                                4,
                        PinnedHost =
                                5,
                        NumaHost =
                                6,
                        Default = System,  
                        UserDefined = 1024 
                };
 
                using IDList = ::promeki::List<ID>;
 
                struct Stats {
                                struct Snapshot {
                                                uint64_t allocCount = 0; 
                                                uint64_t allocBytes = 0; 
                                                uint64_t allocFailCount =
                                                        0; 
                                                uint64_t maxAllocBytes =
                                                        0; 
                                                uint64_t releaseCount = 0;  
                                                uint64_t releaseBytes = 0;  
                                                uint64_t copyCount = 0;     
                                                uint64_t copyBytes = 0;     
                                                uint64_t copyFailCount = 0; 
                                                uint64_t fillCount = 0;     
                                                uint64_t fillBytes = 0;     
                                                uint64_t liveCount = 0; 
                                                uint64_t liveBytes = 0; 
                                                uint64_t peakCount = 0; 
                                                uint64_t peakBytes = 0; 
                                                uint64_t peakResidentBytes = 0;
                                };
 
                                Atomic<uint64_t> allocCount{0};     
                                Atomic<uint64_t> allocBytes{0};     
                                Atomic<uint64_t> allocFailCount{0}; 
                                Atomic<uint64_t> maxAllocBytes{0};  
                                Atomic<uint64_t> releaseCount{0};   
                                Atomic<uint64_t> releaseBytes{0};   
                                Atomic<uint64_t> copyCount{0};      
                                Atomic<uint64_t> copyBytes{0};      
                                Atomic<uint64_t> copyFailCount{0};  
                                Atomic<uint64_t> fillCount{0};      
                                Atomic<uint64_t> fillBytes{0};      
                                Atomic<uint64_t> liveCount{0};      
                                Atomic<uint64_t> liveBytes{0};      
                                Atomic<uint64_t> peakCount{0};      
                                Atomic<uint64_t> peakBytes{0};      
                                Atomic<uint64_t> peakResidentBytes{0}; 
 
                                Stats() = default;
                                Stats(const Stats &) = delete;
                                Stats &operator=(const Stats &) = delete;
                                Stats(Stats &&) = delete;
                                Stats &operator=(Stats &&) = delete;
 
                                Snapshot snapshot() const;
 
                                void reset();
 
                                void recordAlloc(uint64_t bytes);
 
                                void recordRelease(uint64_t bytes);
 
                                void recordResidentBytes(uint64_t bytes);
                };
 
                struct Ops {
                                ID     id;   
                                String name; 
                                bool (*isHostAccessible)(
                                        const MemAllocation &
                                                alloc); 
                                void (*alloc)(
                                        MemAllocation &
                                                alloc); 
                                void (*release)(
                                        MemAllocation &
                                                alloc); 
                                Error (*copy)(
                                        const MemAllocation &src, const MemAllocation &dst,
                                        size_t bytes); 
                                Error (*fill)(
                                        void *ptr, size_t bytes,
                                        char value); 
                                Stats *stats =
                                        nullptr; 
                                MemDomain::ID domainId =
                                        MemDomain::Host; 
                };
 
                static ID registerType();
 
                static void registerData(Ops &&ops);
 
                static IDList registeredIDs();
 
                inline MemSpace(ID id = Default);
 
                const String &name() const { return d->name; }
 
                String toString() const { return d->name; }
 
                ID id() const { return d->id; }
 
                MemDomain domain() const { return MemDomain(d->domainId); }
 
                bool isHostAccessible(const MemAllocation &alloc) const { return d->isHostAccessible(alloc); }
 
                inline MemAllocation alloc(size_t bytes, size_t align) const;
 
                inline void release(MemAllocation &alloc) const;
 
                inline Error copy(const MemAllocation &src, const MemAllocation &dst, size_t bytes) const;
 
                Error fill(void *ptr, size_t bytes, char value) const {
                        if (ptr == nullptr) return Error::Invalid;
                        Error err = d->fill(ptr, bytes, value);
                        if (err.isOk()) {
                                d->stats->fillCount.fetchAndAdd(1);
                                d->stats->fillBytes.fetchAndAdd(bytes);
                        }
                        return err;
                }
 
                Stats &stats() const { return *d->stats; }
 
                Stats::Snapshot statsSnapshot() const { return d->stats->snapshot(); }
 
                void resetStats() const { d->stats->reset(); }
 
                StringList statsReport() const;
 
                static StringList allStatsReport();
 
                void logStats() const;
 
                static void logAllStats();
 
                const Ops *data() const { return d; }
 
                bool operator==(const MemSpace &o) const { return d == o.d; }
 
                bool operator!=(const MemSpace &o) const { return d != o.d; }
 
        private:
                const Ops        *d = nullptr;
                static const Ops *lookup(ID id);
};
 
struct MemAllocation {
                void    *ptr = nullptr;  
                size_t   size = 0;       
                size_t   align = 0;      
                MemSpace ms;             
                void    *priv = nullptr; 
 
                bool isValid() const { return ptr != nullptr; }
};
 
inline MemSpace::MemSpace(ID id) : d(lookup(id)) {}
 
inline Error MemSpace::copy(const MemAllocation &src, const MemAllocation &dst, size_t bytes) const {
        if (src.ptr == nullptr || dst.ptr == nullptr) {
                d->stats->copyFailCount.fetchAndAdd(1);
                return Error::Invalid;
        }
        Error err = d->copy(src, dst, bytes);
        if (err.isOk()) {
                d->stats->copyCount.fetchAndAdd(1);
                d->stats->copyBytes.fetchAndAdd(bytes);
        } else {
                d->stats->copyFailCount.fetchAndAdd(1);
        }
        return err;
}
 
inline MemAllocation MemSpace::alloc(size_t bytes, size_t align) const {
        MemAllocation a;
        a.size = bytes;
        a.align = align;
        a.ms = *this;
        // A zero-byte allocation is valid (returns a.ptr == nullptr) but
        // does not count as a failure. Skip stats so counters aren't
        // polluted by the legitimate empty-buffer case.
        if (bytes == 0) return a;
        d->alloc(a);
        if (a.ptr != nullptr) {
                d->stats->recordAlloc(static_cast<uint64_t>(bytes));
        } else {
                d->stats->allocFailCount.fetchAndAdd(1);
        }
        return a;
}
 
inline void MemSpace::release(MemAllocation &alloc) const {
        if (alloc.ptr == nullptr) return;
        uint64_t bytes = static_cast<uint64_t>(alloc.size);
        d->release(alloc);
        d->stats->recordRelease(bytes);
        alloc.ptr = nullptr;
        alloc.priv = nullptr;
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE