memspace.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/error.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct MemAllocation;
 
class MemSpace {
        public:
                enum ID {
                        System = 0,     
                        SystemSecure,   
                        Default = System 
                };
 
                struct Ops {
                        ID id;                                                              
                        String name;                                                        
                        bool (*isHostAccessible)(const MemAllocation &alloc);                
                        void (*alloc)(MemAllocation &alloc);                                             
                        void (*release)(MemAllocation &alloc);                                          
                        bool (*copy)(const MemAllocation &src, const MemAllocation &dst, size_t bytes); 
                        Error (*fill)(void *ptr, size_t bytes, char value);                              
                };
 
                MemSpace(ID id = Default) : d(lookup(id)) { }
 
                const String &name() const { return d->name; }
 
                ID id() const { return d->id; }
 
                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 bool 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;
                        return d->fill(ptr, bytes, value);
                }
 
        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 bool MemSpace::copy(const MemAllocation &src, const MemAllocation &dst, size_t bytes) const {
        if(src.ptr == nullptr || dst.ptr == nullptr) return false;
        return d->copy(src, dst, bytes);
}
 
inline MemAllocation MemSpace::alloc(size_t bytes, size_t align) const {
        MemAllocation a;
        a.size = bytes;
        a.align = align;
        a.ms = *this;
        d->alloc(a);
        return a;
}
 
inline void MemSpace::release(MemAllocation &alloc) const {
        if(alloc.ptr == nullptr) return;
        d->release(alloc);
        alloc.ptr = nullptr;
        alloc.priv = nullptr;
}
 
PROMEKI_NAMESPACE_END