folly/experimental/fibers/FiberManager.cpp

   1 /*
   2  * Copyright 2015 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include "FiberManager.h"
  17
  18 #include <sys/syscall.h>
  19 #include <unistd.h>
  20
  21 #include <cassert>
  22 #include <stdexcept>
  23
  24 #include <glog/logging.h>
  25
  26 #include <folly/experimental/fibers/Fiber.h>
  27 #include <folly/experimental/fibers/LoopController.h>
  28
  29 namespace folly { namespace fibers {
  30
  31 FOLLY_TLS FiberManager* FiberManager::currentFiberManager_ = nullptr;
  32
  33 FiberManager::FiberManager(std::unique_ptr<LoopController> loopController,
  34                            Options options) :
  35     FiberManager(LocalType<void>(),
  36                  std::move(loopController),
  37                  std::move(options)) {}
  38
  39 FiberManager::~FiberManager() {
  40   if (isLoopScheduled_) {
  41     loopController_->cancel();
  42   }
  43
  44   while (!fibersPool_.empty()) {
  45     fibersPool_.pop_front_and_dispose([] (Fiber* fiber) {
  46       delete fiber;
  47     });
  48   }
  49   assert(readyFibers_.empty());
  50   assert(fibersActive_ == 0);
  51 }
  52
  53 LoopController& FiberManager::loopController() {
  54   return *loopController_;
  55 }
  56
  57 const LoopController& FiberManager::loopController() const {
  58   return *loopController_;
  59 }
  60
  61 bool FiberManager::hasTasks() const {
  62   return fibersActive_ > 0 ||
  63          !remoteReadyQueue_.empty() ||
  64          !remoteTaskQueue_.empty();
  65 }
  66
  67 Fiber* FiberManager::getFiber() {
  68   Fiber* fiber = nullptr;
  69   if (fibersPool_.empty()) {
  70     fiber = new Fiber(*this);
  71     ++fibersAllocated_;
  72   } else {
  73     fiber = &fibersPool_.front();
  74     fibersPool_.pop_front();
  75     assert(fibersPoolSize_ > 0);
  76     --fibersPoolSize_;
  77   }
  78   assert(fiber);
  79   ++fibersActive_;
  80   ++fiberId_;
  81   bool recordStack = (options_.recordStackEvery != 0) &&
  82                      (fiberId_ % options_.recordStackEvery == 0);
  83   fiber->init(recordStack);
  84   return fiber;
  85 }
  86
  87 void FiberManager::setExceptionCallback(FiberManager::ExceptionCallback ec) {
  88   assert(ec);
  89   exceptionCallback_ = std::move(ec);
  90 }
  91
  92 size_t FiberManager::fibersAllocated() const {
  93   return fibersAllocated_;
  94 }
  95
  96 size_t FiberManager::fibersPoolSize() const {
  97   return fibersPoolSize_;
  98 }
  99
 100 size_t FiberManager::stackHighWatermark() const {
 101   return stackHighWatermark_;
 102 }
 103
 104 void FiberManager::remoteReadyInsert(Fiber* fiber) {
 105   if (observer_) {
 106     observer_->runnable(reinterpret_cast<uintptr_t>(fiber));
 107   }
 108   if (remoteReadyQueue_.insertHead(fiber)) {
 109     loopController_->scheduleThreadSafe();
 110   }
 111 }
 112
 113 void FiberManager::setObserver(ExecutionObserver* observer) {
 114   observer_ = observer;
 115 }
 116
 117 }}