completed thesisHEADmaster

4 files changed, 299 insertions, 0 deletions

diff --git a/python/openvino/runtime/streaming/image_streaming_app/uio/CMakeLists.txt b/python/openvino/runtime/streaming/image_streaming_app/uio/CMakeLists.txt
new file mode 100644
index 0000000..4c445a2
--- /dev/null
+++ b/python/openvino/runtime/streaming/image_streaming_app/uio/CMakeLists.txt
@@ -0,0 +1,35 @@
+# Copyright 2023 Intel Corporation
+#
+# This software and the related documents are Intel copyrighted materials,
+# and your use of them is governed by the express license under which they
+# were provided to you ("License"). Unless the License provides otherwise,
+# you may not use, modify, copy, publish, distribute, disclose or transmit
+# this software or the related documents without Intel's prior written
+# permission.
+#
+# This software and the related documents are provided as is, with no express
+# or implied warranties, other than those that are expressly stated in the
+# License.
+
+project(uio)
+
+set(header_files "")
+set(source_files "")
+
+# specify the C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Header files
+set(header_files ${header_files} "include/IUioDevice.h")
+set(header_files ${header_files} "source/UioDevice.h")
+
+# Source files
+set(source_files ${source_files} "source/UioDevice.cpp")
+
+set(all_files ${header_files} ${source_files})
+
+add_library(${PROJECT_NAME} STATIC ${all_files})
+
+# Include directories
+target_include_directories(${PROJECT_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
diff --git a/python/openvino/runtime/streaming/image_streaming_app/uio/include/IUioDevice.h b/python/openvino/runtime/streaming/image_streaming_app/uio/include/IUioDevice.h
new file mode 100644
index 0000000..9b964a7
--- /dev/null
+++ b/python/openvino/runtime/streaming/image_streaming_app/uio/include/IUioDevice.h
@@ -0,0 +1,40 @@
+// Copyright 2023 Intel Corporation.
+//
+// This software and the related documents are Intel copyrighted materials,
+// and your use of them is governed by the express license under which they
+// were provided to you ("License"). Unless the License provides otherwise,
+// you may not use, modify, copy, publish, distribute, disclose or transmit
+// this software or the related documents without Intel's prior written
+// permission.
+//
+// This software and the related documents are provided as is, with no express
+// or implied warranties, other than those that are expressly stated in the
+// License.
+
+#pragma once
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace UIO {
+class DeviceItem {
+ public:
+  std::string _name;
+  uint32_t _index;
+  std::string _indexedName;
+  std::filesystem::path _rootPath;
+};
+
+class IDevice {
+ public:
+  static std::shared_ptr<IDevice> Load(const std::string& deviceName, uint32_t index = 0);
+  static std::vector<DeviceItem> GetDevices();
+
+  virtual uint32_t Read(uint32_t registerIndex) = 0;
+  virtual void Write(uint32_t registerIndex, uint32_t value) = 0;
+  virtual void ReadBlock(void* host_addr, size_t offset, size_t size) = 0;
+  virtual void WriteBlock(const void* host_addr, size_t offset, size_t size) = 0;
+};
+
+}  // namespace UIO
diff --git a/python/openvino/runtime/streaming/image_streaming_app/uio/source/UioDevice.cpp b/python/openvino/runtime/streaming/image_streaming_app/uio/source/UioDevice.cpp
new file mode 100644
index 0000000..d1b5d17
--- /dev/null
+++ b/python/openvino/runtime/streaming/image_streaming_app/uio/source/UioDevice.cpp
@@ -0,0 +1,168 @@
+// Copyright 2023 Intel Corporation.
+//
+// This software and the related documents are Intel copyrighted materials,
+// and your use of them is governed by the express license under which they
+// were provided to you ("License"). Unless the License provides otherwise,
+// you may not use, modify, copy, publish, distribute, disclose or transmit
+// this software or the related documents without Intel's prior written
+// permission.
+//
+// This software and the related documents are provided as is, with no express
+// or implied warranties, other than those that are expressly stated in the
+// License.
+
+#include "UioDevice.h"
+#include <fcntl.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <filesystem>
+#include <fstream>
+
+namespace UIO {
+static const std::string uioDriverFolder = "/sys/class/uio";
+
+std::shared_ptr<IDevice> IDevice::Load(const std::string& deviceName, uint32_t index) {
+  std::vector<DeviceItem> deviceItems = GetDevices();
+  std::string indexedDeviceName = deviceName + std::to_string(index);
+
+  for (auto& deviceItem : deviceItems) {
+    if (deviceItem._indexedName == indexedDeviceName) {
+      auto spUioDevice = std::make_shared<Device>(deviceItem);
+      return spUioDevice->IsValid() ? spUioDevice : nullptr;
+    }
+  }
+
+  return nullptr;
+}
+
+std::vector<DeviceItem> IDevice::GetDevices() {
+  std::vector<DeviceItem> deviceItems;
+
+  for (const auto& entry : std::filesystem::directory_iterator(uioDriverFolder)) {
+    // Filter out uio*
+    if (entry.is_directory()) {
+      std::filesystem::path filePath = entry.path();
+      std::string stem = filePath.filename();
+      if (stem.substr(0, 3) == "uio") {
+        std::string indexedDeviceName = Device::ReadStringFromFile(filePath / "name");
+        if (not indexedDeviceName.empty()) {
+          std::string deviceName;
+          uint32_t index = 0;
+          Device::SplitIndexedDeviceName(indexedDeviceName, deviceName, index);
+          deviceItems.push_back({deviceName, index, indexedDeviceName, filePath});
+        }
+      }
+    }
+  }
+
+  return deviceItems;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+Device::Device(const DeviceItem& deviceItem) : _deviceItem(deviceItem) { MapRegion(); }
+
+Device::~Device() { UnmapRegion(); }
+
+bool Device::IsValid() { return (_fd >= 0); }
+
+uint32_t Device::Read(uint32_t registerIndex) {
+  if (registerIndex >= _maximumRegisterIndex) return 0;
+
+  uint32_t* pRegister = (uint32_t*)_pPtr;
+
+  uint32_t value = pRegister[registerIndex];
+  return value;
+}
+
+void Device::Write(uint32_t registerIndex, uint32_t value) {
+  if (registerIndex < _maximumRegisterIndex) {
+    uint32_t* pRegister = (uint32_t*)_pPtr;
+    pRegister[registerIndex] = value;
+  }
+}
+
+void Device::ReadBlock(void* pHostDestination, size_t offset, size_t size) {
+  if ((offset + size) < _size) {
+    uint8_t* pDeviceMem = (uint8_t*)_pPtr + offset;
+    ::memcpy(pHostDestination, pDeviceMem, size);
+  }
+}
+
+void Device::WriteBlock(const void* pHostSourceAddress, size_t offset, size_t size) {
+  if ((offset + size) < _size) {
+    uint8_t* pDeviceMem = (uint8_t*)_pPtr + offset;
+    ::memcpy(pDeviceMem, pHostSourceAddress, size);
+  }
+}
+
+uint64_t Device::ReadValueFromFile(const std::filesystem::path& path) {
+  std::string line = ReadStringFromFile(path);
+  int base = (line.substr(0, 2) == "0x") ? 16 : 10;
+  return std::stoull(line, nullptr, base);
+}
+
+std::string Device::ReadStringFromFile(const std::filesystem::path& path) {
+  std::ifstream inputStream(path);
+  if (inputStream.good()) {
+    std::string line;
+    std::getline(inputStream, line);
+    return line;
+  }
+  return "";
+}
+
+bool Device::MapRegion() {
+  _size = ReadValueFromFile(_deviceItem._rootPath / "maps/map0/size");
+  _offset = ReadValueFromFile(_deviceItem._rootPath / "maps/map0/offset");
+  _physicalAddress = ReadValueFromFile(_deviceItem._rootPath / "maps/map0/addr");
+  _maximumRegisterIndex = _size / sizeof(uint32_t);
+
+  std::filesystem::path uioDevicePath = "/dev";
+  std::filesystem::path uioDeviceId = _deviceItem._rootPath.stem();
+  uioDevicePath /= uioDeviceId;
+
+  _fd = ::open(uioDevicePath.c_str(), O_RDWR);
+  if (_fd < 0) {
+    return false;
+  }
+
+  // Map the region into userspace
+  _pBase = (uint8_t*)::mmap(NULL, (size_t)_size, PROT_READ | PROT_WRITE, MAP_SHARED, _fd, 0);
+  if (_pBase == MAP_FAILED) {
+    return false;
+  }
+
+  // CST base address is at _pBase + _offset
+  _pPtr = (uint32_t*)(_pBase + _offset);
+
+  return true;
+};
+
+void Device::UnmapRegion() {
+  int r = 0;
+  if (_pBase) {
+    r = ::munmap(_pBase, _size);
+    _pBase = nullptr;
+  }
+
+  if (_fd >= 0) {
+    r = ::close(_fd);
+    _fd = -1;
+  }
+  (void)r;
+}
+
+void Device::SplitIndexedDeviceName(const std::string& indexedDeviceName, std::string& deviceName, uint32_t& index) {
+  int32_t len = static_cast<int32_t>(indexedDeviceName.length());
+  int32_t nDecimals = 0;
+  for (int32_t i = (len - 1); i >= 0; i--) {
+    if (::isdigit(indexedDeviceName[i])) nDecimals++;
+  }
+
+  deviceName = indexedDeviceName.substr(0, len - nDecimals);
+  index = std::stoul(indexedDeviceName.substr(len - nDecimals));
+}
+
+}  // namespace UIO
diff --git a/python/openvino/runtime/streaming/image_streaming_app/uio/source/UioDevice.h b/python/openvino/runtime/streaming/image_streaming_app/uio/source/UioDevice.h
new file mode 100644
index 0000000..49c6f51
--- /dev/null
+++ b/python/openvino/runtime/streaming/image_streaming_app/uio/source/UioDevice.h
@@ -0,0 +1,56 @@
+// Copyright 2023 Intel Corporation.
+//
+// This software and the related documents are Intel copyrighted materials,
+// and your use of them is governed by the express license under which they
+// were provided to you ("License"). Unless the License provides otherwise,
+// you may not use, modify, copy, publish, distribute, disclose or transmit
+// this software or the related documents without Intel's prior written
+// permission.
+//
+// This software and the related documents are provided as is, with no express
+// or implied warranties, other than those that are expressly stated in the
+// License.
+
+#pragma once
+
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <vector>
+#include "IUioDevice.h"
+
+namespace UIO {
+class Device : public IDevice {
+ public:
+  Device(const DeviceItem& deviceItem);
+  ~Device();
+
+  // IDevice interface
+  uint32_t Read(uint32_t registerIndex) override;
+  void Write(uint32_t registerIndex, uint32_t value) override;
+  void ReadBlock(void* host_addr, size_t offset, size_t size) override;
+  void WriteBlock(const void* host_addr, size_t offset, size_t size) override;
+
+  bool IsValid();
+  static uint64_t ReadValueFromFile(const std::filesystem::path& path);
+  static std::string ReadStringFromFile(const std::filesystem::path& path);
+  static void SplitIndexedDeviceName(const std::string& indexedDeviceName, std::string& deviceName, uint32_t& index);
+
+ private:
+  Device() = delete;
+  Device(Device const&) = delete;
+  void operator=(Device const&) = delete;
+
+  bool MapRegion();
+  void UnmapRegion();
+
+  DeviceItem _deviceItem;
+  uint32_t _maximumRegisterIndex = 0;
+  int _fd = -1;  // File pointer to UIO - Used to indicate the the Device is valid
+  uint64_t _physicalAddress = 0;
+  uint64_t _size = 0;         // Size of the mmapped region
+  uint64_t _offset = 0;       // Offset of the first register
+  uint8_t* _pBase = nullptr;  // Base of the mmapped region
+  uint32_t* _pPtr = nullptr;  // The first register
+};
+}  // namespace UIO