buffercommand.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cassert>
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/error.h>
#include <promeki/sharedptr.h>
#include <promeki/atomic.h>
#include <promeki/mutex.h>
#include <promeki/waitcondition.h>
#include <promeki/memdomain.h>
#include <promeki/buffermapflags.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class EventLoop;
 
#define PROMEKI_BUFFER_COMMAND(NAME, KIND_TAG)                                                                         \
public:                                                                                                                \
        Kind kind() const override {                                                                                   \
                return KIND_TAG;                                                                                       \
        }                                                                                                              \
        NAME *_promeki_clone() const {                                                                                 \
                assert(false && #NAME " should not be cloned");                                                        \
                return nullptr;                                                                                        \
        }
 
class BufferCommand {
        public:
                enum Kind {
                        Map,   
                        Unmap, 
                        Copy,  
                };
 
                using Ptr = SharedPtr<BufferCommand, false>;
 
                RefCount _promeki_refct;
 
                BufferCommand *_promeki_clone() const {
                        assert(false && "BufferCommand should never be cloned");
                        return nullptr;
                }
 
                BufferCommand() = default;
                virtual ~BufferCommand() = default;
 
                virtual Kind kind() const = 0;
 
                static const char *kindName(Kind k);
 
                const char *kindName() const { return kindName(kind()); }
 
                // ---- Cancellation ----
 
                Atomic<bool> cancelled{false};
 
                // ---- Output (filled by the backend) ----
 
                Error result = Error::Ok;
 
                // ---- Completion ----
 
                void markCompleted();
 
                Error waitForCompletion(unsigned int timeoutMs = 0) const;
 
                bool isCompleted() const { return _completed.value(); }
 
                void setCompletionCallback(Function<void(Error)> cb, EventLoop *loop);
 
        private:
                Atomic<bool>               _completed{false};
                mutable Mutex              _completionMutex;
                mutable WaitCondition      _completionCv;
                Mutex                      _callbackMutex;
                Function<void(Error)> _callback;
                EventLoop                 *_callbackLoop = nullptr;
};
 
class BufferMapCommand : public BufferCommand {
                PROMEKI_BUFFER_COMMAND(BufferMapCommand, Map)
        public:
                // ---- Inputs ----
 
                MemDomain target;
                MapFlags  flags = MapFlags::Read;
 
                // ---- Outputs ----
 
                void *hostPtr = nullptr;
};
 
class BufferCopyCommand : public BufferCommand {
                PROMEKI_BUFFER_COMMAND(BufferCopyCommand, Copy)
        public:
                // ---- Inputs ----
 
                size_t bytes = 0;
                size_t srcOffset = 0;
                size_t dstOffset = 0;
};
 
class BufferUnmapCommand : public BufferCommand {
                PROMEKI_BUFFER_COMMAND(BufferUnmapCommand, Unmap)
        public:
                // ---- Inputs ----
 
                MemDomain target;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE