Pool.h

Go to the documentation of this file.

 
#ifndef __ROGUE_INTERFACES_STREAM_POOL_H__
#define __ROGUE_INTERFACES_STREAM_POOL_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <memory>
#include <queue>
#include <thread>
 
#include "rogue/EnableSharedFromThis.h"
#include "rogue/Queue.h"
 
namespace rogue {
namespace interfaces {
namespace stream {
 
class Frame;
class Buffer;
 
class Pool : public rogue::EnableSharedFromThis<rogue::interfaces::stream::Pool> {
    // Mutex
    std::mutex mtx_;
 
    // Track buffer allocations
    uint32_t allocMeta_;
 
    // Total memory allocated
    uint32_t allocBytes_;
 
    // Total buffers allocated
    uint32_t allocCount_;
 
    // Buffer queue
    std::queue<uint8_t*> dataQ_;
 
    // Fixed size buffer mode
    uint32_t fixedSize_;
 
    // Buffer queue count
    uint32_t poolSize_;
 
  public:
    Pool();
 
    virtual ~Pool();
 
    uint32_t getAllocBytes();
 
    uint32_t getAllocCount();
 
    virtual std::shared_ptr<rogue::interfaces::stream::Frame> acceptReq(uint32_t size, bool zeroCopyEn);
 
    virtual void retBuffer(uint8_t* data, uint32_t meta, uint32_t size);
 
    static void setup_python();
 
    void setFixedSize(uint32_t size);
 
    uint32_t getFixedSize();
 
    void setPoolSize(uint32_t size);
 
    uint32_t getPoolSize();
 
  protected:
    std::shared_ptr<rogue::interfaces::stream::Buffer> allocBuffer(uint32_t size, uint32_t* total);
 
    std::shared_ptr<rogue::interfaces::stream::Buffer> createBuffer(void* data,
                                                                    uint32_t meta,
                                                                    uint32_t size,
                                                                    uint32_t alloc);
 
    void decCounter(uint32_t alloc);
};
 
typedef std::shared_ptr<rogue::interfaces::stream::Pool> PoolPtr;
}  // namespace stream
}  // namespace interfaces
}  // namespace rogue
#endif