private void submitChildrenProcedures(Procedure<TEnvironment>[] subprocs) { for (int i = 0; i < subprocs.length; ++i) { Procedure<TEnvironment> subproc = subprocs[i]; subproc.updateMetricsOnSubmit(getEnvironment()); assert !procedures.containsKey(subproc.getProcId()); procedures.put(subproc.getProcId(), subproc); scheduler.addFront(subproc); } }
private void load(final boolean abortOnCorruption) throws IOException { Preconditions.checkArgument(completed.isEmpty(), "completed not empty"); Preconditions.checkArgument(rollbackStack.isEmpty(), "rollback state not empty"); Preconditions.checkArgument(procedures.isEmpty(), "procedure map not empty"); Preconditions.checkArgument(scheduler.size() == 0, "run queue not empty"); store.load(new ProcedureStore.ProcedureLoader() { @Override public void setMaxProcId(long maxProcId) { assert lastProcId.get() < 0 : "expected only one call to setMaxProcId()"; lastProcId.set(maxProcId); } @Override public void load(ProcedureIterator procIter) throws IOException { loadProcedures(procIter, abortOnCorruption); } @Override public void handleCorrupted(ProcedureIterator procIter) throws IOException { int corruptedCount = 0; while (procIter.hasNext()) { Procedure<?> proc = procIter.next(); LOG.error("Corrupt " + proc); corruptedCount++; } if (abortOnCorruption && corruptedCount > 0) { throw new IOException("found " + corruptedCount + " corrupted procedure(s) on replay"); } } }); }
@VisibleForTesting public void join() { assert !isRunning() : "expected not running"; // stop the timeout executor timeoutExecutor.awaitTermination(); // stop the worker threads for (WorkerThread worker: workerThreads) { worker.awaitTermination(); } // Destroy the Thread Group for the executors // TODO: Fix. #join is not place to destroy resources. try { threadGroup.destroy(); } catch (IllegalThreadStateException e) { LOG.error("ThreadGroup {} contains running threads; {}: See STDOUT", this.threadGroup, e.getMessage()); // This dumps list of threads on STDOUT. this.threadGroup.list(); } // reset the in-memory state for testing completed.clear(); rollbackStack.clear(); procedures.clear(); nonceKeysToProcIdsMap.clear(); scheduler.clear(); lastProcId.set(-1); }
private long pushProcedure(Procedure<TEnvironment> proc) { final long currentProcId = proc.getProcId(); // Update metrics on start of a procedure proc.updateMetricsOnSubmit(getEnvironment()); // Create the rollback stack for the procedure RootProcedureState<TEnvironment> stack = new RootProcedureState<>(); rollbackStack.put(currentProcId, stack); // Submit the new subprocedures assert !procedures.containsKey(currentProcId); procedures.put(currentProcId, proc); sendProcedureAddedNotification(currentProcId); scheduler.addBack(proc); return proc.getProcId(); }
private void yieldProcedure(Procedure<TEnvironment> proc) { releaseLock(proc, false); scheduler.yield(proc); }
public void stop() { if (!running.getAndSet(false)) { return; } LOG.info("Stopping"); scheduler.stop(); timeoutExecutor.sendStopSignal(); }
public void setKeepAliveTime(final long keepAliveTime, final TimeUnit timeUnit) { this.keepAliveTime = timeUnit.toMillis(keepAliveTime); this.scheduler.signalAll(); }
@Override public void run() { while (true) { TestProcedureWithEvent proc = (TestProcedureWithEvent)sched.poll(); if (proc == null) continue; proc.getEvent().suspend(); waitQueue.add(proc); proc.getEvent().suspendIfNotReady(proc); LOG.debug("WAIT " + proc.getEvent()); if (waitCount.incrementAndGet() >= NRUNS) { break; } } } };
private void procedureFinished(Procedure<TEnvironment> proc) { // call the procedure completion cleanup handler execCompletionCleanup(proc); CompletedProcedureRetainer<TEnvironment> retainer = new CompletedProcedureRetainer<>(proc); // update the executor internal state maps if (!proc.shouldWaitClientAck(getEnvironment())) { retainer.setClientAckTime(0); } completed.put(proc.getProcId(), retainer); rollbackStack.remove(proc.getProcId()); procedures.remove(proc.getProcId()); // call the runnableSet completion cleanup handler try { scheduler.completionCleanup(proc); } catch (Throwable e) { // Catch NullPointerExceptions or similar errors... LOG.error("CODE-BUG: uncatched runtime exception for completion cleanup: {}", proc, e); } // Notify the listeners sendProcedureFinishedNotification(proc.getProcId()); }
scheduler.start();
procExecutor.getScheduler().clear();
private long pushProcedure(final Procedure proc) { final long currentProcId = proc.getProcId(); // Update metrics on start of a procedure proc.updateMetricsOnSubmit(getEnvironment()); // Create the rollback stack for the procedure RootProcedureState stack = new RootProcedureState(); rollbackStack.put(currentProcId, stack); // Submit the new subprocedures assert !procedures.containsKey(currentProcId); procedures.put(currentProcId, proc); sendProcedureAddedNotification(currentProcId); scheduler.addBack(proc); return proc.getProcId(); }
public void stop() { if (!running.getAndSet(false)) { return; } LOG.info("Stopping"); scheduler.stop(); timeoutExecutor.sendStopSignal(); }
public void setKeepAliveTime(final long keepAliveTime, final TimeUnit timeUnit) { this.keepAliveTime = timeUnit.toMillis(keepAliveTime); this.scheduler.signalAll(); }
@Override public void run() { while (true) { TestProcedureWithEvent proc = (TestProcedureWithEvent)sched.poll(); if (proc == null) continue; proc.getEvent().suspend(); waitQueue.add(proc); proc.getEvent().suspendIfNotReady(proc); LOG.debug("WAIT " + proc.getEvent()); if (waitCount.incrementAndGet() >= NRUNS) { break; } } } };