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 __thread 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   Fiber* fiberIt;
  45   Fiber* fiberItNext;
  46   while (!fibersPool_.empty()) {
  47     fibersPool_.pop_front_and_dispose([] (Fiber* fiber) {
  48       delete fiber;
  49     });
  50   }
  51   assert(readyFibers_.empty());
  52   assert(fibersActive_ == 0);
  53 }
  54
  55 LoopController& FiberManager::loopController() {
  56   return *loopController_;
  57 }
  58
  59 const LoopController& FiberManager::loopController() const {
  60   return *loopController_;
  61 }
  62
  63 bool FiberManager::hasTasks() const {
  64   return fibersActive_ > 0 ||
  65          !remoteReadyQueue_.empty() ||
  66          !remoteTaskQueue_.empty();
  67 }
  68
  69 Fiber* FiberManager::getFiber() {
  70   Fiber* fiber = nullptr;
  71   if (fibersPool_.empty()) {
  72     fiber = new Fiber(*this);
  73     ++fibersAllocated_;
  74   } else {
  75     fiber = &fibersPool_.front();
  76     fibersPool_.pop_front();
  77     assert(fibersPoolSize_ > 0);
  78     --fibersPoolSize_;
  79   }
  80   assert(fiber);
  81   ++fibersActive_;
  82   ++fiberId_;
  83   bool recordStack = (options_.recordStackEvery != 0) &&
  84                      (fiberId_ % options_.recordStackEvery == 0);
  85   fiber->init(recordStack);
  86   return fiber;
  87 }
  88
  89 void FiberManager::setExceptionCallback(FiberManager::ExceptionCallback ec) {
  90   assert(ec);
  91   exceptionCallback_ = std::move(ec);
  92 }
  93
  94 size_t FiberManager::fibersAllocated() const {
  95   return fibersAllocated_;
  96 }
  97
  98 size_t FiberManager::fibersPoolSize() const {
  99   return fibersPoolSize_;
 100 }
 101
 102 size_t FiberManager::stackHighWatermark() const {
 103   return stackHighWatermark_;
 104 }
 105
 106 void FiberManager::remoteReadyInsert(Fiber* fiber) {
 107   if (remoteReadyQueue_.insertHead(fiber)) {
 108     loopController_->scheduleThreadSafe();
 109   }
 110 }
 111
 112 void FiberManager::setObserver(ExecutionObserver* observer) {
 113   observer_ = observer;
 114 }
 115
 116 }}