Question

我需要在一系列输入参数上运行任务，运行时间差异很大。我使用parallel :: clusterMap（）与动态调度并行执行此操作。有时计算时间对于单个问题是不可行的。有没有办法在一些预定义的时间限制后杀死集群并仍然检索已完成的任务？

如果我只是设置超时参数，则群集将被终止，而不会检索已完成的任务。最小的例子（不工作！）：</ p>

.factory('StopwatchFactory', ['$interval', function ($interval) {

return function(options){

    var startTime = 0,
        currentTime = null,
        offset = 0,
        interval = null,
        self = this;

    if(!options.interval){
        options.interval = 100;
    }

    options.elapsedTime = new Date(0);

    self.running = false;

    function pushToLog(lap){
        if(options.log !== undefined){
            options.log.push(lap); 
        }
    }

    self.updateTime = function(){
        currentTime = new Date().getTime();
        var timeElapsed = offset + (currentTime - startTime);
        options.elapsedTime.setTime(timeElapsed);
    };

    self.startTimer = function(){
        if(self.running === false){
            startTime = new Date().getTime();
            interval = $interval(self.updateTime,options.interval);
            self.running = true;
        }
    };

    self.stopTimer = function(){
        if( self.running === false) {
            return;
        }
        self.updateTime();
        offset = offset + currentTime - startTime;
        pushToLog(currentTime - startTime);
        $interval.cancel(interval);  
        self.running = false;
    };

    self.resetTimer = function(){
        startTime = new Date().getTime();
        options.elapsedTime.setTime(0);
        timeElapsed = offset = 0;
    };

    self.cancelTimer = function(){
        $interval.cancel(interval);
    };

    var startStop = $scope.startStop;

    self.startStopTimer = function (startStop) {
        if (startStop === "Start") {
            startTimer();
            $scope.startStop = "Stop";
        } else {
            stopTimer();
            $scope.startStop = "Start";
        }
    };

    return self;

};
}]);

Answer 1

我不会杀死工人，相反，我会让工人在一段时间后自行停止工作。

这是一个非常接近您发布的代码的示例：每个工作程序在t秒内处于活动状态，但不超过4秒。在t或4秒后，它会停止并返回到目前为止所做的事情：

f <- function(t) {
  executionTime <- 0
  while(executionTime < t & executionTime < 4) {
    executionTime <- executionTime + 1
    Sys.sleep(1)
  }
  return(executionTime)
}
t <- c(1, 1, 2, 15, 2, 1, 3, 4, 1, 1, 1,3)


cl <- makeCluster(3)
print(as.numeric(clusterMap(cl, f, t, .scheduling = "dynamic")))
stopCluster(cl)

# [1] 1 1 2 4 2 1 3 4 1 1 1 3

注意第四个元素是4，而不是15.工人迭代4次/ 4秒，然后停止并返回4.

限制clusterMap中每个子问题的计算时间（R并行包）

1 个答案: