[onert] Implement BulkPipeline operation for multi-model execution

Implement BulkPipeline operation to enable efficient multi-model
execution with pipeline parallelism. This adds comprehensive pipeline
management including buffer sharing, asynchronous execution, and model
coordination for improved performance.

ONE-DCO-1.0-Signed-off-by: Jonghwa Lee <jonghwa3.lee@samsung.com>

Author: batcheu

runtime/onert/backend/trix/KernelGenerator.cc

@@ -16,6 +16,7 @@
 
 #include "KernelGenerator.h"
 
+#include "ops/BulkPipeLayer.h"
 #include "ops/BulkLayer.h"
 
 #include <backend/Backend.h>
@@ -66,11 +67,20 @@ void KernelGenerator::visit(const ir::operation::Bulk &node)
   // parameters
   const auto &binary_path = node.param().binary_path;
 
-  auto fn = std::make_unique<ops::BulkLayer>();
-
-  fn->configure(input_tensors, output_tensors, binary_path.front(), _dev_context);
-
-  _return_fn = std::move(fn);
+  if (binary_path.size() == 1)
+  {
+    // For single model execution
+    auto fn = std::make_unique<ops::BulkLayer>();
+    fn->configure(input_tensors, output_tensors, binary_path.front(), _dev_context);
+    _return_fn = std::move(fn);
+  }
+  else
+  {
+    // For pipeline execution (multiple models)
+    auto fn = std::make_unique<ops::BulkPipeLayer>();
+    fn->configure(input_tensors, output_tensors, binary_path);
+    _return_fn = std::move(fn);
+  }
 }
 
 } // namespace onert::backend::trix

runtime/onert/backend/trix/ops/BulkPipeLayer.cc

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BulkPipeLayer.h"
+
+#include <iostream>
+#include <memory>
+
+namespace onert
+{
+namespace backend
+{
+namespace trix
+{
+namespace ops
+{
+
+BulkPipeLayer::BulkPipeLayer() : _inputs(), _outputs()
+{
+  // DO NOTHING
+}
+
+BulkPipeLayer::~BulkPipeLayer()
+{
+  // DO NOTHING - _pipeline_manager will be automatically cleaned up by unique_ptr
+}
+
+void BulkPipeLayer::configure(const std::vector<const IPortableTensor *> &inputs,
+                              std::vector<IPortableTensor *> &outputs,
+                              const std::vector<std::string> &binary_path)
+{
+  _inputs = inputs;
+  _outputs = outputs;
+
+  // Configure BulkPipeLineManager
+  BulkPipelineManager::PipelineConfig config;
+  config.model_paths = binary_path;
+  config.device_id = 0;        // default device id = 0
+  config.buffer_pool_size = 2; // Use 2 buffers
+
+  _pipeline_manager = std::make_unique<BulkPipelineManager>(config);
+
+  if (!_pipeline_manager->initialize())
+  {
+    throw std::runtime_error("Failed to initialize bulk pipeline manager");
+  }
+}
+
+void BulkPipeLayer::run()
+{
+  if (!_pipeline_manager)
+  {
+    throw std::runtime_error("Pipeline manager is not initialized");
+  }
+
+  try
+  {
+    _pipeline_manager->execute(_inputs, _outputs);
+  }
+  catch (const std::exception &e)
+  {
+    std::cerr << "BulkPipeLayer execution failed: " << e.what() << std::endl;
+    throw;
+  }
+}
+
+void BulkPipeLayer::prepare()
+{
+  // DO NOTHING
+}
+
+} // namespace ops
+} // namespace trix
+} // namespace backend
+} // namespace onert

runtime/onert/backend/trix/ops/BulkPipeLayer.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __ONERT_BACKEND_TRIX_OPS_BULKPIPELAYER_H__
+#define __ONERT_BACKEND_TRIX_OPS_BULKPIPELAYER_H__
+
+#include <backend/IPortableTensor.h>
+#include "../DevContext.h"
+#include <exec/IFunction.h>
+#include "BulkPipelineManager.h"
+
+namespace onert
+{
+namespace backend
+{
+namespace trix
+{
+namespace ops
+{
+
+class BulkPipeLayer : public ::onert::exec::IFunction
+{
+public:
+  BulkPipeLayer();
+  ~BulkPipeLayer() override;
+
+public:
+  void configure(const std::vector<const IPortableTensor *> &inputs,
+                 std::vector<IPortableTensor *> &outputs,
+                 const std::vector<std::string> &binary_path);
+
+  void run() override;
+
+  void prepare() override;
+
+private:
+  std::vector<const IPortableTensor *> _inputs;
+  std::vector<IPortableTensor *> _outputs;
+
+  // Pipeline manager
+  std::unique_ptr<BulkPipelineManager> _pipeline_manager;
+};
+
+} // namespace ops
+} // namespace trix
+} // namespace backend
+} // namespace onert
+
+#endif // __ONERT_BACKEND_TRIX_OPS_BULKPIPELAYER_H__

runtime/onert/backend/trix/ops/BulkPipelineBuffer.cc

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "BulkPipelineBuffer.h"
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+
+namespace onert
+{
+namespace backend
+{
+namespace trix
+{
+namespace ops
+{
+
+// FIXME: Using higher level API instead of raw API
+struct trix_ioctl_hwmem
+{
+  int32_t type;
+  uint64_t size;
+  int32_t dbuf_fd;
+} __attribute__((packed));
+
+#define TRIX_IOCTL_HWMEM_ALLOC _IOW(136, 21, struct trix_ioctl_hwmem)
+#define TRIX_IOCTL_HWMEM_DEALLOC _IOW(136, 22, struct trix_ioctl_hwmem)
+
+BulkPipelineBuffer::BulkPipelineBuffer(BufferType type, size_t size, int device_id)
+  : _type(type), _size(size), _device_id(device_id), _memory_type(getMemoryType())
+{
+  // DO NOTHING
+}
+
+BulkPipelineBuffer::~BulkPipelineBuffer() { deallocate(); }
+
+BulkPipelineBuffer::BulkPipelineBuffer(BulkPipelineBuffer &&other) noexcept
+  : _type(other._type), _size(other._size), _device_id(other._device_id), _dev_fd(other._dev_fd),
+    _buffer(other._buffer), _memory_type(other._memory_type)
+{
+  other._dev_fd = -1;
+  other._buffer = nullptr;
+}
+
+BulkPipelineBuffer &BulkPipelineBuffer::operator=(BulkPipelineBuffer &&other) noexcept
+{
+  if (this != &other)
+  {
+    deallocate();
+
+    _type = other._type;
+    _size = other._size;
+    _device_id = other._device_id;
+    _dev_fd = other._dev_fd;
+    _buffer = other._buffer;
+    _memory_type = other._memory_type;
+
+    other._dev_fd = -1;
+    other._buffer = nullptr;
+  }
+  return *this;
+}
+
+void *BulkPipelineBuffer::data() const { return _buffer ? _buffer->addr : nullptr; }
+
+size_t BulkPipelineBuffer::size() const { return _buffer ? _buffer->size : 0; }
+
+int BulkPipelineBuffer::dmabufFd() const { return _buffer ? _buffer->dmabuf : -1; }
+
+bool BulkPipelineBuffer::isReady() const { return _buffer && _buffer->addr != nullptr; }
+
+void BulkPipelineBuffer::allocate()
+{
+  if (_buffer && _buffer->addr != nullptr)
+  {
+    // Already allocated
+    return;
+  }
+
+  if (!_buffer)
+  {
+    _buffer = new generic_buffer{};
+  }
+
+  // Open the devbice
+  char devname[16];
+  snprintf(devname, sizeof(devname), "/dev/triv2-%d", _device_id);
+  _dev_fd = open(devname, O_RDWR);
+  if (_dev_fd < 0)
+  {
+    throw BufferAllocationException("Failed to open NPU device: " + std::string(devname));
+  }
+
+  // Allocate a buffer
+  struct trix_ioctl_hwmem hwmem;
+  hwmem.type = (_memory_type == MemoryType::DMABUF_CONT) ? 0 : 1;
+  hwmem.size = getAlignedSize(_size);
+
+  _buffer->dmabuf = ioctl(_dev_fd, TRIX_IOCTL_HWMEM_ALLOC, &hwmem);
+  if (_buffer->dmabuf < 0)
+  {
+    close(_dev_fd);
+    _dev_fd = -1;
+    throw BufferAllocationException("Failed to allocate DMA buffer, size: " +
+                                    std::to_string(hwmem.size));
+  }
+
+  // Mapping the buffer
+  _buffer->addr = mmap(nullptr, hwmem.size, PROT_READ | PROT_WRITE, MAP_SHARED, _buffer->dmabuf, 0);
+  if (_buffer->addr == MAP_FAILED)
+  {
+    close(_buffer->dmabuf);
+    close(_dev_fd);
+    _buffer->dmabuf = -1;
+    _dev_fd = -1;
+    _buffer->addr = nullptr;
+    throw BufferAllocationException("Failed to mmap DMA buffer");
+  }
+
+  _buffer->size = _size;
+  _buffer->type = BUFFER_DMABUF;
+}
+
+void BulkPipelineBuffer::deallocate()
+{
+  if (!_buffer)
+  {
+    return;
+  }
+
+  if (_buffer->addr != nullptr)
+  {
+    size_t aligned_sz = getAlignedSize(_buffer->size);
+    munmap(_buffer->addr, aligned_sz);
+    _buffer->addr = nullptr;
+  }
+
+  if (_buffer->dmabuf >= 0)
+  {
+    struct trix_ioctl_hwmem hwmem;
+    hwmem.dbuf_fd = _buffer->dmabuf;
+    ioctl(_dev_fd, TRIX_IOCTL_HWMEM_DEALLOC, &hwmem);
+    close(_buffer->dmabuf);
+    _buffer->dmabuf = -1;
+  }
+
+  if (_dev_fd >= 0)
+  {
+    close(_dev_fd);
+    _dev_fd = -1;
+  }
+
+  delete _buffer;
+  _buffer = nullptr;
+}
+
+void BulkPipelineBuffer::fillFromFile(FILE *fp, size_t offset)
+{
+  if (!isReady())
+  {
+    throw BufferOperationException("Buffer is not allocated");
+  }
+
+  if (!fp)
+  {
+    throw BufferOperationException("Invalid file pointer");
+  }
+
+  if (fseek(fp, static_cast<long>(offset), SEEK_SET) != 0)
+  {
+    throw BufferOperationException("Failed to seek file to offset: " + std::to_string(offset));
+  }
+
+  if (fread(_buffer->addr, _buffer->size, 1, fp) != 1)
+  {
+    throw BufferOperationException("Failed to read " + std::to_string(_buffer->size) +
+                                   " bytes from file");
+  }
+}
+
+size_t BulkPipelineBuffer::getAlignedSize(size_t size) const
+{
+  // 4 KB (= Page size) aligned size
+  constexpr size_t _4KB_M_1 = (1 << 12) - 1;
+  return (size + _4KB_M_1) & ~_4KB_M_1;
+}
+
+BulkPipelineBuffer::MemoryType BulkPipelineBuffer::getMemoryType() const
+{
+  return (_type == BufferType::PROGRAM) ? MemoryType::DMABUF_CONT : MemoryType::DMABUF_IOMMU;
+}
+
+} // namespace ops
+} // namespace trix
+} // namespace backend
+} // namespace onert