Examples with CheckpointableTask edu.iu.dsc.tws.checkpointing.task.CheckpointableTask used on opensource projects

Example 1 with CheckpointableTask

use of edu.iu.dsc.tws.checkpointing.task.CheckpointableTask in project twister2 by DSC-SPIDAL.

the class ExecutionPlanBuilder method build.

@Override
public ExecutionPlan build(Config cfg, ComputeGraph taskGraph, TaskSchedulePlan taskSchedule) {
    // we need to build the task plan
    LogicalPlan logicalPlan = TaskPlanBuilder.build(workerId, workerInfoList, taskSchedule, taskIdGenerator);
    ParallelOperationFactory opFactory = new ParallelOperationFactory(cfg, network, logicalPlan);
    Map<Integer, WorkerSchedulePlan> containersMap = taskSchedule.getContainersMap();
    WorkerSchedulePlan conPlan = containersMap.get(workerId);
    if (conPlan == null) {
        LOG.log(Level.INFO, "Cannot find worker in the task plan: " + workerId);
        return null;
    }
    ExecutionPlan execution = new ExecutionPlan();
    Set<TaskInstancePlan> instancePlan = conPlan.getTaskInstances();
    long tasksVersion = 0L;
    if (CheckpointingContext.isCheckpointingEnabled(cfg)) {
        Set<Integer> globalTasks = Collections.emptySet();
        if (workerId == 0) {
            globalTasks = containersMap.values().stream().flatMap(containerPlan -> containerPlan.getTaskInstances().stream()).filter(ip -> taskGraph.vertex(ip.getTaskName()).getTask() instanceof CheckpointableTask && !(taskGraph.vertex(ip.getTaskName()).getTask() instanceof CheckpointingSGatherSink)).map(TaskInstancePlan::getTaskId).collect(Collectors.toSet());
        }
        try {
            Checkpoint.FamilyInitializeResponse familyInitializeResponse = this.checkpointingClient.initFamily(workerId, containersMap.size(), taskGraph.getGraphName(), globalTasks);
            tasksVersion = familyInitializeResponse.getVersion();
        } catch (BlockingSendException e) {
            throw new RuntimeException("Failed to register tasks with Checkpoint Manager", e);
        }
        LOG.info("Tasks will start with version " + tasksVersion);
    }
    // for each task we are going to create the communications
    for (TaskInstancePlan ip : instancePlan) {
        Vertex v = taskGraph.vertex(ip.getTaskName());
        Map<String, Set<String>> inEdges = new HashMap<>();
        Map<String, String> outEdges = new HashMap<>();
        if (v == null) {
            throw new RuntimeException("Non-existing task scheduled: " + ip.getTaskName());
        }
        INode node = v.getTask();
        if (node instanceof ICompute || node instanceof ISource) {
            // lets get the communication
            Set<Edge> edges = taskGraph.outEdges(v);
            // now lets create the communication object
            for (Edge e : edges) {
                Vertex child = taskGraph.childOfTask(v, e.getName());
                // lets figure out the parents task id
                Set<Integer> srcTasks = taskIdGenerator.getTaskIds(v, ip.getTaskId());
                Set<Integer> tarTasks = taskIdGenerator.getTaskIds(child, getTaskIdOfTask(child.getName(), taskSchedule));
                Map<Integer, Integer> srcGlobalToIndex = taskIdGenerator.getGlobalTaskToIndex(v, ip.getTaskId());
                Map<Integer, Integer> tarGlobaToIndex = taskIdGenerator.getGlobalTaskToIndex(child, getTaskIdOfTask(child.getName(), taskSchedule));
                createCommunication(child, e, v, srcTasks, tarTasks, srcGlobalToIndex, tarGlobaToIndex);
                outEdges.put(e.getName(), child.getName());
            }
        }
        if (node instanceof ICompute) {
            // lets get the parent tasks
            Set<Edge> parentEdges = taskGraph.inEdges(v);
            for (Edge e : parentEdges) {
                Vertex parent = taskGraph.getParentOfTask(v, e.getName());
                // lets figure out the parents task id
                Set<Integer> srcTasks = taskIdGenerator.getTaskIds(parent, getTaskIdOfTask(parent.getName(), taskSchedule));
                Set<Integer> tarTasks = taskIdGenerator.getTaskIds(v, ip.getTaskId());
                Map<Integer, Integer> srcGlobalToIndex = taskIdGenerator.getGlobalTaskToIndex(parent, getTaskIdOfTask(parent.getName(), taskSchedule));
                Map<Integer, Integer> tarGlobalToIndex = taskIdGenerator.getGlobalTaskToIndex(v, ip.getTaskId());
                createCommunication(v, e, parent, srcTasks, tarTasks, srcGlobalToIndex, tarGlobalToIndex);
                // if we are a grouped edge, we have to use the group name
                String inEdge;
                if (e.getTargetEdge() == null) {
                    inEdge = e.getName();
                } else {
                    inEdge = e.getTargetEdge();
                }
                Set<String> parents = inEdges.get(inEdge);
                if (parents == null) {
                    parents = new HashSet<>();
                }
                parents.add(inEdge);
                inEdges.put(inEdge, parents);
            }
        }
        // lets create the instance
        INodeInstance iNodeInstance = createInstances(cfg, taskGraph.getGraphName(), ip, v, taskGraph.getOperationMode(), inEdges, outEdges, taskSchedule, tasksVersion);
        // add to execution
        execution.addNodes(v.getName(), taskIdGenerator.generateGlobalTaskId(ip.getTaskId(), ip.getTaskIndex()), iNodeInstance);
    }
    // now lets create the queues and start the execution
    for (Table.Cell<String, String, Communication> cell : parOpTable.cellSet()) {
        Communication c = cell.getValue();
        // lets create the communication
        OperationMode operationMode = taskGraph.getOperationMode();
        IParallelOperation op;
        assert c != null;
        c.build();
        if (c.getEdge().size() == 1) {
            op = opFactory.build(c.getEdge(0), c.getSourceTasks(), c.getTargetTasks(), operationMode, c.srcGlobalToIndex, c.tarGlobalToIndex);
        } else if (c.getEdge().size() > 1) {
            // just join op for now. Could change in the future
            // here the sources should be separated out for left and right edge
            Set<Integer> sourceTasks = c.getSourceTasks();
            Set<Integer> leftSources = new HashSet<>();
            Set<Integer> rightSources = new HashSet<>();
            if (!sourceTasks.isEmpty()) {
                // just to safely do .get() calls without isPresent()
                int minBin = (sourceTasks.stream().min(Integer::compareTo).get() / TaskIdGenerator.TASK_OFFSET) * TaskIdGenerator.TASK_OFFSET;
                for (Integer source : sourceTasks) {
                    if ((source / TaskIdGenerator.TASK_OFFSET) * TaskIdGenerator.TASK_OFFSET == minBin) {
                        leftSources.add(source);
                    } else {
                        rightSources.add(source);
                    }
                }
            }
            // now determine, which task is connected to which edge
            Edge leftEdge = c.getEdge(0);
            Edge rightEdge = c.getEdge(1);
            op = opFactory.build(leftEdge, rightEdge, leftSources, rightSources, c.getTargetTasks(), operationMode, c.srcGlobalToIndex, c.tarGlobalToIndex);
        } else {
            throw new RuntimeException("Cannot have communication with 0 edges");
        }
        // now lets check the sources and targets that are in this executor
        Set<Integer> sourcesOfThisWorker = intersectionOfTasks(conPlan, c.getSourceTasks());
        Set<Integer> targetsOfThisWorker = intersectionOfTasks(conPlan, c.getTargetTasks());
        // we use the target edge as the group name
        String targetEdge;
        if (c.getEdge().size() > 1) {
            targetEdge = c.getEdge(0).getTargetEdge();
        } else {
            targetEdge = c.getEdge(0).getName();
        }
        // so along with the operation mode, the windowing mode must be tested
        if (operationMode == OperationMode.STREAMING) {
            for (Integer i : sourcesOfThisWorker) {
                boolean found = false;
                // we can have multiple source tasks for an operation
                for (int sIndex = 0; sIndex < c.getSourceTask().size(); sIndex++) {
                    String sourceTask = c.getSourceTask().get(sIndex);
                    if (streamingTaskInstances.contains(sourceTask, i)) {
                        TaskStreamingInstance taskStreamingInstance = streamingTaskInstances.get(sourceTask, i);
                        taskStreamingInstance.registerOutParallelOperation(c.getEdge(sIndex).getName(), op);
                        op.registerSync(i, taskStreamingInstance);
                        found = true;
                    } else if (streamingSourceInstances.contains(sourceTask, i)) {
                        SourceStreamingInstance sourceStreamingInstance = streamingSourceInstances.get(sourceTask, i);
                        sourceStreamingInstance.registerOutParallelOperation(c.getEdge(sIndex).getName(), op);
                        found = true;
                    }
                    if (!found) {
                        throw new RuntimeException("Not found: " + c.getSourceTask());
                    }
                }
            }
            // we only have one target task always
            for (Integer i : targetsOfThisWorker) {
                if (streamingTaskInstances.contains(c.getTargetTask(), i)) {
                    TaskStreamingInstance taskStreamingInstance = streamingTaskInstances.get(c.getTargetTask(), i);
                    op.register(i, taskStreamingInstance.getInQueue());
                    taskStreamingInstance.registerInParallelOperation(targetEdge, op);
                    op.registerSync(i, taskStreamingInstance);
                } else {
                    throw new RuntimeException("Not found: " + c.getTargetTask());
                }
            }
            execution.addOps(op);
        }
        if (operationMode == OperationMode.BATCH) {
            for (Integer i : sourcesOfThisWorker) {
                boolean found = false;
                // we can have multiple source tasks for an operation
                for (int sIndex = 0; sIndex < c.getSourceTask().size(); sIndex++) {
                    String sourceTask = c.getSourceTask().get(sIndex);
                    if (batchTaskInstances.contains(sourceTask, i)) {
                        TaskBatchInstance taskBatchInstance = batchTaskInstances.get(sourceTask, i);
                        taskBatchInstance.registerOutParallelOperation(c.getEdge(sIndex).getName(), op);
                        found = true;
                    } else if (batchSourceInstances.contains(sourceTask, i)) {
                        SourceBatchInstance sourceBatchInstance = batchSourceInstances.get(sourceTask, i);
                        sourceBatchInstance.registerOutParallelOperation(c.getEdge(sIndex).getName(), op);
                        found = true;
                    }
                }
                if (!found) {
                    throw new RuntimeException("Not found: " + c.getSourceTask());
                }
            }
            for (Integer i : targetsOfThisWorker) {
                if (batchTaskInstances.contains(c.getTargetTask(), i)) {
                    TaskBatchInstance taskBatchInstance = batchTaskInstances.get(c.getTargetTask(), i);
                    op.register(i, taskBatchInstance.getInQueue());
                    taskBatchInstance.registerInParallelOperation(targetEdge, op);
                    op.registerSync(i, taskBatchInstance);
                } else {
                    throw new RuntimeException("Not found: " + c.getTargetTask());
                }
            }
            execution.addOps(op);
        }
    }
    return execution;
}

Example 2 with CheckpointableTask

use of edu.iu.dsc.tws.checkpointing.task.CheckpointableTask in project twister2 by DSC-SPIDAL.

the class SourceStreamingInstance method prepare.

public void prepare(Config cfg) {
    outputStreamingCollection = new DefaultOutputCollection(outStreamingQueue);
    taskContext = new TaskContextImpl(streamingTaskIndex, taskId, globalTaskId, taskName, parallelism, workerId, outputStreamingCollection, nodeConfigs, outEdges, taskSchedule, OperationMode.STREAMING);
    streamingTask.prepare(cfg, taskContext);
    // / we will use this array for iteration
    this.outOpArray = new IParallelOperation[outStreamingParOps.size()];
    int index = 0;
    for (Map.Entry<String, IParallelOperation> e : outStreamingParOps.entrySet()) {
        this.outOpArray[index++] = e.getValue();
    }
    this.outEdgeArray = new String[outEdges.size()];
    index = 0;
    for (String e : outEdges.keySet()) {
        this.outEdgeArray[index++] = e;
    }
    if (this.checkpointable) {
        this.stateStore = CheckpointUtils.getStateStore(config);
        this.stateStore.init(config, this.taskGraphName, String.valueOf(globalTaskId));
        TaskCheckpointUtils.restore((CheckpointableTask) this.streamingTask, this.snapshot, this.stateStore, this.tasksVersion, globalTaskId);
        this.checkpointVersion = this.tasksVersion + 1;
        this.pendingCheckpoint = new PendingCheckpoint(taskGraphName, (CheckpointableTask) this.streamingTask, globalTaskId, outOpArray, outEdges.size(), checkpointingClient, stateStore, snapshot);
    }
}

Example 3 with CheckpointableTask

use of edu.iu.dsc.tws.checkpointing.task.CheckpointableTask in project twister2 by DSC-SPIDAL.

the class TaskStreamingInstance method execute.

/**
 * Executing compute task
 */
public boolean execute() {
    // execute if there are incoming messages
    while (!inQueue.isEmpty() && outQueue.size() < lowWaterMark) {
        IMessage m = inQueue.poll();
        if (m != null) {
            task.execute(m);
        }
    }
    // set the initial nothing to execute
    boolean nothingToProcess = inQueue.isEmpty();
    // now check the output queue
    while (!outQueue.isEmpty()) {
        IMessage message = outQueue.peek();
        if (message != null) {
            String edge = message.edge();
            boolean barrierMessage = (message.getFlag() & MessageFlags.SYNC_BARRIER) == MessageFlags.SYNC_BARRIER;
            // invoke the communication operation
            IParallelOperation op = outParOps.get(edge);
            // if we successfully send remove
            if (barrierMessage ? op.sendBarrier(globalTaskId, (byte[]) message.getContent()) : op.send(globalTaskId, message, message.getFlag())) {
                outQueue.poll();
            } else {
                nothingToProcess = false;
                break;
            }
        }
    }
    for (int i = 0; i < outOpArray.length; i++) {
        boolean needProgress = outOpArray[i].progress();
        if (needProgress) {
            nothingToProcess = false;
        }
    }
    for (int i = 0; i < intOpArray.length; i++) {
        boolean needProgress = intOpArray[i].progress();
        if (needProgress) {
            nothingToProcess = false;
        }
    }
    if (this.checkpointable && this.inQueue.isEmpty() && this.outQueue.isEmpty()) {
        long checkpointedBarrierId = this.pendingCheckpoint.execute();
        if (checkpointedBarrierId != -1) {
            ((CheckpointableTask) this.task).onCheckpointPropagated(this.snapshot);
            taskContext.write(CheckpointingSGatherSink.FT_GATHER_EDGE, checkpointedBarrierId);
            this.scheduleBarriers(checkpointedBarrierId);
            nothingToProcess = false;
        }
    }
    return !nothingToProcess;
}

Example 4 with CheckpointableTask

use of edu.iu.dsc.tws.checkpointing.task.CheckpointableTask in project twister2 by DSC-SPIDAL.

the class TaskStreamingInstance method prepare.

/**
 * Preparing the task
 *
 * @param cfg configuration
 */
public void prepare(Config cfg) {
    outputCollection = new DefaultOutputCollection(outQueue);
    taskContext = new TaskContextImpl(taskIndex, taskId, globalTaskId, taskName, parallelism, workerId, outputCollection, nodeConfigs, inputEdges, outputEdges, taskSchedule, OperationMode.STREAMING);
    task.prepare(cfg, taskContext);
    // / we will use this array for iteration
    this.outOpArray = new IParallelOperation[outParOps.size()];
    int index = 0;
    for (Map.Entry<String, IParallelOperation> e : outParOps.entrySet()) {
        this.outOpArray[index++] = e.getValue();
    }
    this.outEdgeArray = new String[outputEdges.size()];
    index = 0;
    for (String e : outputEdges.keySet()) {
        this.outEdgeArray[index++] = e;
    }
    // / we will use this array for iteration
    this.intOpArray = new IParallelOperation[inParOps.size()];
    index = 0;
    for (Map.Entry<String, IParallelOperation> e : inParOps.entrySet()) {
        this.intOpArray[index++] = e.getValue();
    }
    this.inEdgeArray = new String[inputEdges.size()];
    index = 0;
    for (String e : inputEdges.keySet()) {
        this.inEdgeArray[index++] = e;
    }
    if (this.checkpointable) {
        this.stateStore = CheckpointUtils.getStateStore(config);
        this.stateStore.init(config, this.taskGraphName, String.valueOf(globalTaskId));
        this.pendingCheckpoint = new PendingCheckpoint(this.taskGraphName, (CheckpointableTask) this.task, this.globalTaskId, this.intOpArray, this.inEdgeArray.length, this.checkpointingClient, this.stateStore, this.snapshot);
        TaskCheckpointUtils.restore((CheckpointableTask) this.task, this.snapshot, this.stateStore, this.tasksVersion, globalTaskId);
    }
}

Example 5 with CheckpointableTask

use of edu.iu.dsc.tws.checkpointing.task.CheckpointableTask in project twister2 by DSC-SPIDAL.

the class SourceStreamingInstance method execute.

/**
 * Execution Method calls the SourceTasks run method to get context
 */
public boolean execute() {
    if (outStreamingQueue.size() < lowWaterMark && !(this.checkpointable && this.pendingCheckpoint.isPending())) {
        // lets execute the task
        streamingTask.execute();
        if (this.checkpointable && (executions++ % this.checkPointingFrequency) == 0) {
            this.scheduleCheckpoint(checkpointVersion++);
        }
    }
    // we start with setting nothing to execute true
    boolean nothingToProcess = true;
    // now check the output queue
    while (!outStreamingQueue.isEmpty()) {
        IMessage message = outStreamingQueue.peek();
        if (message != null) {
            String edge = message.edge();
            IParallelOperation op = outStreamingParOps.get(edge);
            boolean barrierMessage = (message.getFlag() & MessageFlags.SYNC_BARRIER) == MessageFlags.SYNC_BARRIER;
            // if we successfully send remove message
            if (barrierMessage ? op.sendBarrier(globalTaskId, (byte[]) message.getContent()) : op.send(globalTaskId, message, message.getFlag())) {
                outStreamingQueue.poll();
            } else {
                nothingToProcess = false;
                // we need to break
                break;
            }
        } else {
            break;
        }
    }
    for (int i = 0; i < outOpArray.length; i++) {
        boolean needProgress = outOpArray[i].progress();
        if (needProgress) {
            nothingToProcess = false;
        }
    }
    if (this.checkpointable && outStreamingQueue.isEmpty() && this.pendingCheckpoint.isPending()) {
        long barrier = this.pendingCheckpoint.execute();
        if (barrier != -1) {
            ((CheckpointableTask) this.streamingTask).onCheckpointPropagated(this.snapshot);
            this.scheduleBarriers(barrier);
            taskContext.write(CheckpointingSGatherSink.FT_GATHER_EDGE, barrier);
            nothingToProcess = false;
        }
    }
    return !nothingToProcess;
}