shmem_buffer.h

Go to the documentation of this file.

 
// Copyright (c) Space-ng, inc. All rights reserved.
 
#pragma once
 
#include "sol3/core/message_port.h"
#include "sol3/core/msg/buffer.h"
#include "sol3/core/msg/exchange_config.h"
 
#include <boost/asio/local/datagram_protocol.hpp>
#include <unistd.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>
 
struct gbm_bo;
 
namespace sol3::core {
 
using Endpoint = boost::asio::local::datagram_protocol::endpoint;
 
namespace msg {
 
// NOLINTBEGIN(readability-identifier-naming)
std::string format_as(BufferInfo const&);
std::string format_as(BufferFormat const&);
// NOLINTEND(readability-identifier-naming)
}  // namespace msg
 
using msg::BufferInfo;
 
struct EndpointPort {
  boost::asio::local::datagram_protocol::endpoint endpoint;
  MessagePort port;
 
  bool operator==(EndpointPort const& rhs) const {
    return endpoint == rhs.endpoint && port.encoded() == rhs.port.encoded();
  }
 
  bool operator!=(EndpointPort const& rhs) const { return !(*this == rhs); }
 
  bool operator<(EndpointPort const& rhs) const {
    if (endpoint != rhs.endpoint) {
      return endpoint < rhs.endpoint;
    }
    if (port.encoded() != rhs.port.encoded()) {
      return port.encoded() < rhs.port.encoded();
    }
    return false;
  }
};
 
struct PortIdx {
  uint32_t port = 0;
  uint32_t idx = 0;
  bool operator<(PortIdx const& o) const {
    return port != o.port ? port < o.port : idx < o.idx;
  }
  bool operator==(PortIdx const& o) const {
    return port == o.port && idx == o.idx;
  }
};
 
class IBufferConst {
 public:
  virtual ~IBufferConst() = default;
 
  virtual BufferInfo const& info() const = 0;
 
  virtual void const* data() const = 0;
 
  virtual size_t size() const = 0;
 
  virtual int fd() const = 0;
 
  virtual Endpoint const& endpoint() const = 0;
};
 
class IBufferMutable : public IBufferConst {
 public:
  virtual void* mutableData() = 0;
  virtual gbm_bo* gbmBo() const { return nullptr; };
};
 
bool isGpu(msg::BufferFormat format);
 
std::unique_ptr<IBufferMutable> makeShmemBuffer(BufferInfo const& info);
 
std::unique_ptr<IBufferConst> importShmemBufferConst(
    BufferInfo const& info, int fd, Endpoint const& endpoint);
 
class IBufferExchange {
 public:
  using Endpoint = boost::asio::local::datagram_protocol::endpoint;
  using EndpointPort = sol3::core::EndpointPort;
  using PortIdx = sol3::core::PortIdx;
 
  virtual ~IBufferExchange() = default;
 
  virtual void start() = 0;
 
  virtual void stop() = 0;
 
  virtual bool stopped() const = 0;
 
  virtual Endpoint const& localEndpoint() const = 0;
 
  virtual void addPeer(Endpoint const& peer_endpoint) = 0;
 
  virtual void mapLocalToPeer(
      uint32_t local_port, Endpoint peer_endpoint, uint32_t peer_port = 0) = 0;
 
  virtual void configure(msg::ExchangeConfigT const& config) = 0;
 
  virtual void listPorts(std::vector<EndpointPort>& ports) const = 0;
 
  virtual void registerBuffer(IBufferMutable const& buffer) = 0;
 
  virtual void unregisterBuffer(IBufferMutable const& buffer) = 0;
 
  virtual std::shared_ptr<IBufferConst> get(
      uint32_t id, uint32_t idx) const = 0;
 
  virtual std::shared_ptr<IBufferConst> get(
      Endpoint const& ep, uint32_t id, uint32_t idx) const = 0;
 
  virtual void dispose(std::shared_ptr<IBufferConst>&& buffer) = 0;
 
  virtual void listMappings(
      std::map<uint32_t, std::vector<std::pair<Endpoint, uint32_t>>>& mappings)
      const = 0;
 
  virtual void listResolvedBuffers(
      std::map<PortIdx, std::shared_ptr<IBufferConst>>& buffers) const = 0;
 
  static std::shared_ptr<IBufferExchange> makeProcessLocal();
};
 
}  // namespace sol3::core
 
namespace std {
template <>
struct hash<sol3::core::PortIdx> {
  size_t operator()(sol3::core::PortIdx const& p) const noexcept {
    return std::hash<uint64_t>{}(uint64_t(p.port) << 32 | p.idx);
  }
};
}  // namespace std