Imported Upstream version 5.18.0.167

Former-commit-id: 289509151e0fee68a1b591a20c9f109c3c789d3a

external/llvm/unittests/ExecutionEngine/Orc/QueueChannel.h

@@ -1,146 +0,0 @@
-//===----------------------- Queue.h - RPC Queue ------------------*-c++-*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_UNITTESTS_EXECUTIONENGINE_ORC_QUEUECHANNEL_H
-#define LLVM_UNITTESTS_EXECUTIONENGINE_ORC_QUEUECHANNEL_H
-
-#include "llvm/ExecutionEngine/Orc/RawByteChannel.h"
-#include "llvm/Support/Error.h"
-
-#include <condition_variable>
-#include <queue>
-
-namespace llvm {
-
-class QueueChannelError : public ErrorInfo<QueueChannelError> {
-public:
-  static char ID;
-};
-
-class QueueChannelClosedError
-    : public ErrorInfo<QueueChannelClosedError, QueueChannelError> {
-public:
-  static char ID;
-  std::error_code convertToErrorCode() const override {
-    return inconvertibleErrorCode();
-  }
-
-  void log(raw_ostream &OS) const override {
-    OS << "Queue closed";
-  }
-};
-
-class Queue : public std::queue<char> {
-public:
-  using ErrorInjector = std::function<Error()>;
-
-  Queue()
-    : ReadError([]() { return Error::success(); }),
-      WriteError([]() { return Error::success(); }) {}
-
-  Queue(const Queue&) = delete;
-  Queue& operator=(const Queue&) = delete;
-  Queue(Queue&&) = delete;
-  Queue& operator=(Queue&&) = delete;
-
-  std::mutex &getMutex() { return M; }
-  std::condition_variable &getCondVar() { return CV; }
-  Error checkReadError() { return ReadError(); }
-  Error checkWriteError() { return WriteError(); }
-  void setReadError(ErrorInjector NewReadError) {
-    {
-      std::lock_guard<std::mutex> Lock(M);
-      ReadError = std::move(NewReadError);
-    }
-    CV.notify_one();
-  }
-  void setWriteError(ErrorInjector NewWriteError) {
-    std::lock_guard<std::mutex> Lock(M);
-    WriteError = std::move(NewWriteError);
-  }
-private:
-  std::mutex M;
-  std::condition_variable CV;
-  std::function<Error()> ReadError, WriteError;
-};
-
-class QueueChannel : public orc::rpc::RawByteChannel {
-public:
-  QueueChannel(std::shared_ptr<Queue> InQueue,
-               std::shared_ptr<Queue> OutQueue)
-      : InQueue(InQueue), OutQueue(OutQueue) {}
-
-  QueueChannel(const QueueChannel&) = delete;
-  QueueChannel& operator=(const QueueChannel&) = delete;
-  QueueChannel(QueueChannel&&) = delete;
-  QueueChannel& operator=(QueueChannel&&) = delete;
-
-  Error readBytes(char *Dst, unsigned Size) override {
-    std::unique_lock<std::mutex> Lock(InQueue->getMutex());
-    while (Size) {
-      {
-        Error Err = InQueue->checkReadError();
-        while (!Err && InQueue->empty()) {
-          InQueue->getCondVar().wait(Lock);
-          Err = InQueue->checkReadError();
-        }
-        if (Err)
-          return Err;
-      }
-      *Dst++ = InQueue->front();
-      --Size;
-      ++NumRead;
-      InQueue->pop();
-    }
-    return Error::success();
-  }
-
-  Error appendBytes(const char *Src, unsigned Size) override {
-    std::unique_lock<std::mutex> Lock(OutQueue->getMutex());
-    while (Size--) {
-      if (Error Err = OutQueue->checkWriteError())
-        return Err;
-      OutQueue->push(*Src++);
-      ++NumWritten;
-    }
-    OutQueue->getCondVar().notify_one();
-    return Error::success();
-  }
-
-  Error send() override { return Error::success(); }
-
-  void close() {
-    auto ChannelClosed = []() { return make_error<QueueChannelClosedError>(); };
-    InQueue->setReadError(ChannelClosed);
-    InQueue->setWriteError(ChannelClosed);
-    OutQueue->setReadError(ChannelClosed);
-    OutQueue->setWriteError(ChannelClosed);
-  }
-
-  uint64_t NumWritten = 0;
-  uint64_t NumRead = 0;
-
-private:
-
-  std::shared_ptr<Queue> InQueue;
-  std::shared_ptr<Queue> OutQueue;
-};
-
-inline std::pair<std::unique_ptr<QueueChannel>, std::unique_ptr<QueueChannel>>
-createPairedQueueChannels() {
-  auto Q1 = std::make_shared<Queue>();
-  auto Q2 = std::make_shared<Queue>();
-  auto C1 = llvm::make_unique<QueueChannel>(Q1, Q2);
-  auto C2 = llvm::make_unique<QueueChannel>(Q2, Q1);
-  return std::make_pair(std::move(C1), std::move(C2));
-}
-
-}
-
-#endif