buffered_channel.h 2.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

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. */

#pragma once
#include <condition_variable>
#include <deque>
#include <mutex>

#include "paddle/framework/channel.h"
C
chengduo 已提交
21
#include "paddle/platform/enforce.h"
22 23 24 25 26 27 28 29 30 31 32 33 34 35

namespace paddle {
namespace framework {
namespace details {

template <typename T>
class Buffered : public paddle::framework::Channel<T> {
  friend Channel<T>* paddle::framework::MakeChannel<T>(size_t);
  friend void paddle::framework::CloseChannel<T>(Channel<T>*);

 public:
  virtual void Send(T*);
  virtual void Receive(T*);
  virtual size_t Cap() { return cap_; }
C
chengduo 已提交
36 37
  virtual void Close();
  virtual ~Buffered();
38 39 40 41 42 43 44

 private:
  size_t cap_;
  std::mutex mu_;
  std::condition_variable empty_cond_var_;
  std::condition_variable full_cond_var_;
  std::deque<T> channel_;
C
chengduo 已提交
45
  bool closed_;
46

C
chengduo 已提交
47 48 49
  Buffered(size_t cap) : cap_(cap), closed_(false) {
    PADDLE_ENFORCE_GT(cap, 0);
  }
50 51 52 53 54 55 56

  void NotifyAllSenders(std::unique_lock<std::mutex>*);
};

template <typename T>
void Buffered<T>::Send(T* item) {
  std::unique_lock<std::mutex> lock(mu_);
C
chengduo 已提交
57 58 59 60 61 62 63
  full_cond_var_.wait(lock,
                      [this]() { return channel_.size() < cap_ || closed_; });
  if (!closed_) {
    channel_.push_back(std::move(*item));
    lock.unlock();
    empty_cond_var_.notify_one();
  }
64 65 66 67 68
}

template <typename T>
void Buffered<T>::Receive(T* item) {
  std::unique_lock<std::mutex> lock(mu_);
C
chengduo 已提交
69 70 71 72 73 74 75 76 77 78 79 80 81 82
  empty_cond_var_.wait(lock, [this]() { return !channel_.empty() || closed_; });
  if (!closed_) {
    *item = std::move(channel_.front());
    channel_.pop_front();
    NotifyAllSenders(&lock);
  } else {
    item = nullptr;
  }
}

template <typename T>
void Buffered<T>::Close() {
  std::unique_lock<std::mutex> lock(mu_);
  closed_ = true;
83 84 85 86 87 88
  NotifyAllSenders(&lock);
}

template <typename T>
Buffered<T>::~Buffered() {
  std::unique_lock<std::mutex> lock(mu_);
C
chengduo 已提交
89
  closed_ = true;
90 91 92 93 94 95 96
  channel_.clear();
  NotifyAllSenders(&lock);
}

template <typename T>
void Buffered<T>::NotifyAllSenders(std::unique_lock<std::mutex>* lock) {
  lock->unlock();
C
chengduo 已提交
97
  full_cond_var_.notify_all();
98 99 100 101 102
}

}  // namespace details
}  // namespace framework
}  // namespace paddle