docs: def runController(callable_, *args, **kargs):
      """Callable greenlet implementing controller logic."""
      global execQueue
  
      # initialize and run root future
      rootId = (-1, 0)
  
      # initialise queue
      if execQueue is None:
          execQueue = FutureQueue()
  
          sys.excepthook = advertiseBrokerWorkerDown
  
          if scoop.DEBUG:
              from scoop import _debug
              _debug.redirectSTDOUTtoDebugFile()
  
          # TODO: Make that a function
          # Wait until we received the main module if we are a headless slave
          headless = scoop.CONFIGURATION.get("headless", False)
          if not scoop.MAIN_MODULE:
              # If we're not the origin and still don't have our main_module,
              # wait for it and then import it as module __main___
              main = scoop.shared.getConst('__MAIN_MODULE__', timeout=float('inf'))
              directory_name = tempfile.mkdtemp()
              os.chdir(directory_name)
              scoop.MAIN_MODULE = main.writeFile(directory_name)
              from .bootstrap.__main__ import Bootstrap as SCOOPBootstrap
              newModule = SCOOPBootstrap.setupEnvironment()
              sys.modules['__main__'] = newModule
          elif scoop.IS_ORIGIN and headless and scoop.MAIN_MODULE:
              # We're the origin, share our main_module
              scoop.shared.setConst(
                  __MAIN_MODULE__=scoop.encapsulation.ExternalEncapsulation(
                      scoop.MAIN_MODULE,
                  )
              )
              # TODO: use modulefinder to share every local dependency of
              # main module
  
      # launch future if origin or try to pickup a future if slave worker
      if scoop.IS_ORIGIN:
          future = Future(rootId, callable_, *args, **kargs)
      else:
          future = execQueue.pop()
  
      future.greenlet = greenlet.greenlet(runFuture)
      future = future._switch(future)
  
      if scoop.DEBUG:
          lastDebugTs = time.time()
  
      while not scoop.IS_ORIGIN or future.parentId != rootId or not future._ended():
          if scoop.DEBUG and time.time() - lastDebugTs > scoop.TIME_BETWEEN_PARTIALDEBUG:
              _debug.writeWorkerDebug(
                  debug_stats,
                  QueueLength,
                  "debug/partial-{0}".format(
                      round(time.time(), -1)
                  )
              )
              lastDebugTs = time.time()
          # process future
          if future._ended():
              # future is finished
              if future.id[0] != scoop.worker:
                  # future is not local
                  execQueue.sendResult(future)
                  future = execQueue.pop()
              else:
                  # future is local, parent is waiting
                  if future.index is not None:
                      try:
                          parent = futureDict[future.parentId]
                      except KeyError:
                          # Job has no parent here (probably children restart)
                          future = execQueue.pop()
                      else:
                          if parent.exceptionValue is None:
                              future = parent._switch(future)
                          else:
                              future = execQueue.pop()
                  else:
                      future = execQueue.pop()
          else:
              # future is in progress; run next future from pending execution queue.
              future = execQueue.pop()
  
          if not future._ended() and future.greenlet is None:
              # initialize if the future hasn't started
              future.greenlet = greenlet.greenlet(runFuture)
              future = future._switch(future)
  
      execQueue.shutdown()
      if future.exceptionValue:
          print(future.exceptionTraceback)
          sys.exit(1)
      return future.resultValue