Develop zerocopy

README.md

@@ -174,7 +174,7 @@ The following environment variables can be set to alter default behavior of the
 | DEPTHAI_SEARCH_TIMEOUT | Specifies timeout in milliseconds for device searching in blocking functions. |
 | DEPTHAI_CONNECT_TIMEOUT | Specifies timeout in milliseconds for establishing a connection to a given device. |
 | DEPTHAI_BOOTUP_TIMEOUT | Specifies timeout in milliseconds for waiting the device to boot after sending the binary. |
-| DEPTHAI_PROTOCOL | Restricts default search to the specified protocol. Options: `any`, `usb`, `tcpip`. |
+| DEPTHAI_PROTOCOL | Restricts default search to the specified protocol. Options: `any`, `usb`, `tcpip`, `tcpshd`. |
 | DEPTHAI_PLATFORM | Restricts default search to the specified platform. Options: `any`, `rvc2`, `rvc3`, `rvc4`. |
 | DEPTHAI_DEVICE_MXID_LIST | Restricts default search to the specified MXIDs. Accepts comma separated list of MXIDs. Lists filter results in an "AND" manner and not "OR" |
 | DEPTHAI_DEVICE_ID_LIST | Alias to MXID list. Lists filter results in an "AND" manner and not "OR" |

cmake/Hunter/config.cmake

@@ -11,9 +11,9 @@ hunter_config(
 
 hunter_config(
     XLink
-    VERSION "luxonis-2021.4.3-develop"
-    URL "https://github.com/luxonis/XLink/archive/061709357b06a74510b5b9e3e2832d9d80efd3ff.tar.gz"
-    SHA1 "affa1bdd7487cf70c9caf40365844967ae761ea3"
+    VERSION "luxonis-develop-server"
+    URL "https://github.com/luxonis/XLink/archive/585a38fe4707e5f023de277135d8cb6ff9c4e0c4.tar.gz"
+    SHA1 "d82827dec8b6f2702f4b31d8186fd70265cd0ca4"
     CMAKE_ARGS
         XLINK_ENABLE_LIBUSB=${DEPTHAI_ENABLE_LIBUSB}
 )

examples/CMakeLists.txt

@@ -1,2 +1,2 @@
 add_subdirectory(cpp)
-# add_subdirectory(python)
+# add_subdirectory(python)

include/depthai/pipeline/datatype/ADatatype.hpp

@@ -6,6 +6,7 @@
 #include "depthai/utility/Memory.hpp"
 #include "depthai/utility/Serialization.hpp"
 #include "depthai/utility/VectorMemory.hpp"
+
 namespace dai {
 
 /// Abstract message

include/depthai/pipeline/datatype/Buffer.hpp

@@ -17,6 +17,8 @@ class Buffer : public ADatatype {
    public:
     Buffer() = default;
     Buffer(size_t size);
+    Buffer(long fd);
+    Buffer(long fd, size_t size);
     virtual ~Buffer() = default;
 
     virtual void serialize(std::vector<std::uint8_t>& metadata, DatatypeEnum& datatype) const {
@@ -35,6 +37,7 @@ class Buffer : public ADatatype {
      * @param data Copies data to internal buffer
      */
     void setData(const std::vector<std::uint8_t>& data);
+    void setData(const long fd);
 
     /**
      * @param data Moves data to internal buffer

include/depthai/pipeline/datatype/ImgFrame.hpp

@@ -70,7 +70,9 @@ class ImgFrame : public Buffer {
      * Timestamp is set to now
      */
     ImgFrame();
+    ImgFrame(long fd);
     ImgFrame(size_t size);
+    ImgFrame(long fd, size_t size);
     virtual ~ImgFrame() = default;
 
     ImgTransformations transformations;

include/depthai/utility/Memory.hpp

@@ -107,6 +107,12 @@ holder(std::move(holder)) {}
 };
 */
 
+enum MemoryKinds {
+    MEMORY_KIND_VECTOR,
+    MEMORY_KIND_SHARED,
+    MEMORY_KINDS_COUNT,
+};
+
 // memory as interface
 class Memory {
    public:
@@ -120,6 +126,13 @@ class Memory {
     std::size_t getSize() const {
         return getData().size();
     };
+
+    MemoryKinds getKind() {
+        return kind;
+    }
+
+   protected:
+    MemoryKinds kind;
 };
 
 }  // namespace dai

include/depthai/utility/SharedMemory.hpp

@@ -0,0 +1,125 @@
+#pragma once
+
+// std
+#include <cstdint>
+#include <cstring>
+#include <functional>
+#include <iostream>
+#ifdef __unix__
+    #include <fcntl.h>
+    #include <sys/mman.h>
+    #include <sys/stat.h>
+    #include <sys/un.h>
+    #include <unistd.h>
+#endif
+
+// project
+#include "depthai/utility/Memory.hpp"
+
+namespace dai {
+
+// memory as interface
+class SharedMemory : public Memory {
+   protected:
+    long fd = -1;
+    void* mapping;
+    void mapFd() {
+        if(fd < 0) {
+            /* Error handling here */
+        }
+
+        mapping = mmap(NULL, getSize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        if(mapping == NULL) {
+            /* Error handling here */
+        }
+    }
+    void unmapFd() {
+        if(mapping == NULL) {
+            return;
+        }
+
+        munmap(mapping, getSize());
+    }
+
+   public:
+    SharedMemory() {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        fd = -1;
+    }
+
+    SharedMemory(long argFd) : fd(argFd) {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        mapFd();
+    }
+
+    SharedMemory(long argFd, std::size_t size) : fd(argFd) {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        setSize(size);
+        mapFd();
+    }
+
+    SharedMemory(const char* name) {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        fd = memfd_create(name, 0);
+        mapFd();
+    }
+
+    SharedMemory(const char* name, std::size_t size) {
+        kind = MemoryKinds::MEMORY_KIND_SHARED;
+        fd = memfd_create(name, 0);
+
+        setSize(size);
+        mapFd();
+    }
+
+    ~SharedMemory() {
+        unmapFd();
+        close(fd);
+    }
+
+    SharedMemory& operator=(long argFd) {
+        unmapFd();
+        fd = argFd;
+        mapFd();
+
+        return *this;
+    }
+
+    span<std::uint8_t> getData() override {
+        if(mapping == NULL) {
+            mapFd();
+        }
+
+        return {(uint8_t*)mapping, getSize()};
+    }
+    span<const std::uint8_t> getData() const override {
+        return {(const uint8_t*)mapping, getSize()};
+    }
+    std::size_t getMaxSize() const override {
+        struct stat fileStats;
+        fstat(fd, &fileStats);
+
+        return fileStats.st_size;
+    }
+    std::size_t getOffset() const override {
+        return ftell(fdopen(fd, "r"));
+    }
+    void setSize(std::size_t size) override {
+        if(mapping != NULL) {
+            unmapFd();
+        }
+
+        ftruncate(fd, size);
+        mapFd();
+    }
+
+    std::size_t getSize() const {
+        return getMaxSize();
+    }
+
+    long getFd() const {
+        return fd;
+    }
+};
+
+}  // namespace dai

include/depthai/utility/VectorMemory.hpp

@@ -14,9 +14,15 @@ namespace dai {
 class VectorMemory : public std::vector<std::uint8_t>, public Memory {
    public:
     // using std::vector<std::uint8_t>::vector;
-    VectorMemory() = default;
-    VectorMemory(const std::vector<std::uint8_t>& d) : vector(std::move(d)) {}
-    VectorMemory(std::vector<std::uint8_t>&& d) : vector(std::move(d)) {}
+    VectorMemory() {
+        kind = MemoryKinds::MEMORY_KIND_VECTOR;
+    }
+    VectorMemory(const std::vector<std::uint8_t>& d) : vector(std::move(d)) {
+        kind = MemoryKinds::MEMORY_KIND_VECTOR;
+    }
+    VectorMemory(std::vector<std::uint8_t>&& d) : vector(std::move(d)) {
+        kind = MemoryKinds::MEMORY_KIND_VECTOR;
+    }
     VectorMemory& operator=(std::vector<std::uint8_t>&& d) {
         std::vector<std::uint8_t>::operator=(std::move(d));
         return *this;

include/depthai/xlink/XLinkStream.hpp

@@ -28,7 +28,7 @@ namespace dai {
 
 class StreamPacketDesc : public streamPacketDesc_t {
    public:
-    StreamPacketDesc() noexcept : streamPacketDesc_t{nullptr, 0, {}, {}} {};
+    StreamPacketDesc() noexcept : streamPacketDesc_t{nullptr, 0, -1, {}, {}} {};
     StreamPacketDesc(const StreamPacketDesc&) = delete;
     StreamPacketDesc(StreamPacketDesc&& other) noexcept;
     StreamPacketDesc& operator=(const StreamPacketDesc&) = delete;
@@ -89,11 +89,15 @@ class XLinkStream {
     // Blocking
     void write(span<const uint8_t> data, span<const uint8_t> data2);
     void write(span<const uint8_t> data);
+    void write(long fd);
+    void write(long fd, span<const uint8_t> data);
     void write(const void* data, std::size_t size);
     std::vector<std::uint8_t> read();
     std::vector<std::uint8_t> read(XLinkTimespec& timestampReceived);
     void read(std::vector<std::uint8_t>& data);
+    void read(std::vector<std::uint8_t>& data, long& fd);
     void read(std::vector<std::uint8_t>& data, XLinkTimespec& timestampReceived);
+    void read(std::vector<std::uint8_t>& data, long& fd, XLinkTimespec& timestampReceived);
     // split write helper
     void writeSplit(const void* data, std::size_t size, std::size_t split);
     void writeSplit(const std::vector<uint8_t>& data, std::size_t split);

src/device/DataQueue.cpp

@@ -9,6 +9,7 @@
 #include "depthai/pipeline/datatype/ADatatype.hpp"
 #include "depthai/pipeline/datatype/DatatypeEnum.hpp"
 #include "depthai/pipeline/datatype/MessageGroup.hpp"
+#include "depthai/utility/SharedMemory.hpp"
 #include "depthai/xlink/XLinkStream.hpp"
 #include "pipeline/datatype/MessageGroup.hpp"
 #include "pipeline/datatype/StreamMessageParser.hpp"
@@ -205,8 +206,14 @@ DataInputQueue::DataInputQueue(
 
                 // Blocking
                 auto t1 = steady_clock::now();
+
                 if(outgoing->data->getSize() > 0) {
-                    stream.write(outgoing->data->getData(), metadata);
+                    if(outgoing->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                        stream.write(outgoing->data->getData(), metadata);
+                    } else if(outgoing->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                        std::shared_ptr<SharedMemory> memory = std::dynamic_pointer_cast<SharedMemory>(outgoing->data);
+                        stream.write(memory->getFd(), metadata);
+                    }
                 } else {
                     stream.write(metadata);
                 }
@@ -227,7 +234,12 @@ DataInputQueue::DataInputQueue(
                         logger::trace("Sending part of a group message: {}", msg.first);
                         auto metadata = StreamMessageParser::serializeMetadata(msg.second);
                         if(msg.second->data->getSize() > 0) {
-                            stream.write(msg.second->data->getData(), metadata);
+                            if(msg.second->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                                stream.write(msg.second->data->getData(), metadata);
+                            } else if(msg.second->data->getKind() == dai::MemoryKinds::MEMORY_KIND_VECTOR) {
+                                std::shared_ptr<SharedMemory> memory = std::dynamic_pointer_cast<SharedMemory>(msg.second->data);
+                                stream.write(memory->getFd(), metadata);
+                            }
                         } else {
                             stream.write(metadata);
                         }

src/pipeline/datatype/Buffer.cpp

@@ -1,5 +1,6 @@
 #include "depthai/pipeline/datatype/Buffer.hpp"
 
+#include "depthai/utility/SharedMemory.hpp"
 #include "depthai/utility/VectorMemory.hpp"
 
 namespace dai {
@@ -9,6 +10,16 @@ Buffer::Buffer(size_t size) : Buffer() {
     data = mem;
 }
 
+Buffer::Buffer(long fd) : Buffer() {
+    auto mem = std::make_shared<SharedMemory>(fd);
+    data = mem;
+}
+
+Buffer::Buffer(long fd, size_t size) : Buffer() {
+    auto mem = std::make_shared<SharedMemory>(fd, size);
+    data = mem;
+}
+
 span<uint8_t> Buffer::getData() {
     return data->getData();
 }
@@ -27,6 +38,10 @@ void Buffer::setData(const std::vector<std::uint8_t>& d) {
     }
 }
 
+void Buffer::setData(const long fd) {
+    data = std::make_shared<SharedMemory>(fd);
+}
+
 void Buffer::setData(std::vector<std::uint8_t>&& d) {
     // allocate new holder
     data = std::make_shared<VectorMemory>(std::move(d));

src/pipeline/datatype/ImgFrame.cpp

@@ -1,6 +1,7 @@
 #define _USE_MATH_DEFINES
 #include "depthai/pipeline/datatype/ImgFrame.hpp"
 
+#include "depthai/utility/SharedMemory.hpp"
 #include "spdlog/fmt/fmt.h"
 #include "spdlog/spdlog.h"
 namespace dai {
@@ -16,6 +17,16 @@ ImgFrame::ImgFrame(size_t size) : ImgFrame() {
     data = mem;
 }
 
+ImgFrame::ImgFrame(long fd) : ImgFrame() {
+    auto mem = std::make_shared<SharedMemory>(fd);
+    data = mem;
+}
+
+ImgFrame::ImgFrame(long fd, size_t size) : ImgFrame() {
+    auto mem = std::make_shared<SharedMemory>(fd, size);
+    data = mem;
+}
+
 std::chrono::time_point<std::chrono::steady_clock, std::chrono::steady_clock::duration> ImgFrame::getTimestamp(CameraExposureOffset offset) const {
     auto ts = getTimestamp();
     auto expTime = getExposureTime();