public async Task StreamWriteAsyncTest() { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); MemoryStream stream1 = new MemoryStream(buffer); MemoryStream stream2 = new MemoryStream(); OperationContext tempOperationContext = new OperationContext(); RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null); ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext); // Test basic write await stream1.WriteToAsync(stream2, null, null, false, tempExecutionState, null, CancellationToken.None); stream1.Position = 0; TestHelper.AssertStreamsAreEqual(stream1, stream2); stream2.Dispose(); stream2 = new MemoryStream(); await TestHelper.ExpectedExceptionAsync<ArgumentException>( async () => await stream1.WriteToAsync(stream2, 1024, 1024, false, tempExecutionState, null, CancellationToken.None), "Parameters copyLength and maxLength cannot be passed simultaneously."); stream1.Dispose(); stream2.Dispose(); }
public virtual void Start() { if (_state != ExecutionState.Created) { var message = String.Format("Start() called on Fiber with state: {0}", _state); throw new ThreadStateException(message); } _state = ExecutionState.Running; }
public void StreamWriteSyncTestCopyLengthBoundary() { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); MemoryStream stream1 = new MemoryStream(buffer); MemoryStream stream2 = new MemoryStream(); MemoryStream stream3 = new MemoryStream(); OperationContext tempOperationContext = new OperationContext(); RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null); ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext); // Test write with exact number of bytes stream1.WriteToSync(stream2, stream1.Length, null, true, false, tempExecutionState, null); stream1.Position = 0; stream1.WriteToSync(stream3, stream1.Length, null, true, true, tempExecutionState, null); stream1.Position = 0; TestHelper.AssertStreamsAreEqual(stream1, stream2); TestHelper.AssertStreamsAreEqual(stream1, stream3); stream2.Dispose(); stream2 = new MemoryStream(); stream3.Dispose(); stream3 = new MemoryStream(); // Test write with one less byte stream1.WriteToSync(stream2, stream1.Length - 1, null, true, false, tempExecutionState, null); stream1.Position = 0; stream1.WriteToSync(stream3, stream1.Length - 1, null, true, true, tempExecutionState, null); stream1.Position = 0; Assert.AreEqual(stream1.Length - 1, stream2.Length); Assert.AreEqual(stream1.Length - 1, stream3.Length); TestHelper.AssertStreamsAreEqualAtIndex(stream1, stream2, 0, 0, (int)stream1.Length - 1); TestHelper.AssertStreamsAreEqualAtIndex(stream1, stream3, 0, 0, (int)stream1.Length - 1); stream2.Dispose(); stream2 = new MemoryStream(); stream3.Dispose(); stream3 = new MemoryStream(); // Test with copyLength greater than length TestHelper.ExpectedException<ArgumentOutOfRangeException>( () => stream1.WriteToSync(stream2, stream1.Length + 1, null, true, false, tempExecutionState, null), "The given stream does not contain the requested number of bytes from its given position."); stream1.Position = 0; TestHelper.ExpectedException<ArgumentOutOfRangeException>( () => stream1.WriteToSync(stream3, stream1.Length + 1, null, true, true, tempExecutionState, null), "The given stream does not contain the requested number of bytes from its given position."); stream1.Position = 0; stream1.Dispose(); stream2.Dispose(); stream3.Dispose(); }
public void Start() { // Toggle tthese lines to enable/disable concurrent execution. if (taskExecutionState == ExecutionState.Started) return; taskExecutionState = ExecutionState.Started; foreach (var task in tasks) { task.Execute(); } }
protected virtual void OnExecutionStateChanged(ExecutionState newState){ if (newState == state) { return; } var oldState = state; state = newState; var executionStateChanged = ExecutionStateChanged; if (executionStateChanged != null) { executionStateChanged (this, new ExecutionStateChangedEventArgs (state, oldState)); } }
public async Task WriteToMultiBufferMemoryStreamTestAsync() { OperationContext tempOperationContext = new OperationContext(); RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null); ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext); byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); MemoryStream stream1 = new MemoryStream(buffer); MultiBufferMemoryStream stream2 = new MultiBufferMemoryStream(null /* bufferManager */); await stream1.WriteToAsync(stream2, null, null, false, tempExecutionState, null, CancellationToken.None); stream1.Seek(0, SeekOrigin.Begin); stream2.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream1, stream2); MultiBufferMemoryStream stream3 = new MultiBufferMemoryStream(null /* bufferManager */); await TestHelper.ExpectedExceptionAsync<TimeoutException>( () => stream2.FastCopyToAsync(stream3, DateTime.Now.AddMinutes(-1)), "Past expiration time should immediately fail"); stream2.Seek(0, SeekOrigin.Begin); stream3.Seek(0, SeekOrigin.Begin); await stream2.FastCopyToAsync(stream3, DateTime.Now.AddHours(1)); stream2.Seek(0, SeekOrigin.Begin); stream3.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream2, stream3); MultiBufferMemoryStream stream4 = new MultiBufferMemoryStream(null /* bufferManager */, 12345); await stream3.FastCopyToAsync(stream4, null); stream3.Seek(0, SeekOrigin.Begin); stream4.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream3, stream4); MemoryStream stream5 = new MemoryStream(); await stream4.WriteToAsync(stream5, null, null, false, tempExecutionState, null, CancellationToken.None); stream4.Seek(0, SeekOrigin.Begin); stream5.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream4, stream5); TestHelper.AssertStreamsAreEqual(stream1, stream5); }
private void OnRun(object sender, RoutedEventArgs e) { this.RunButton.Click -= OnRun; this.RunButton.Content = pausePanel; this.RunButton.Click += OnPause; execState = ExecutionState.Running; _runTimer.Elapsed += OnTimer; _runTimer.Start(); }
private void InvokeTyped(DarksVMContext ctx, MethodBase targetMethod, byte opCode, ref uint sp, out ExecutionState state) { var parameters = targetMethod.GetParameters(); var paramCount = parameters.Length; if (!targetMethod.IsStatic && opCode != DarksVMConstants.ECALL_NEWOBJ) { paramCount++; } Type constrainType = null; if (opCode == DarksVMConstants.ECALL_CALLVIRT_CONSTRAINED) { constrainType = (Type)ctx.Instance.Data.LookupReference(ctx.Stack[sp--].U4); } var indexOffset = targetMethod.IsStatic || opCode == DarksVMConstants.ECALL_NEWOBJ ? 0 : 1; var references = new IReference[paramCount]; var types = new Type[paramCount]; for (var i = paramCount - 1; i >= 0; i--) { Type paramType; if (!targetMethod.IsStatic && opCode != DarksVMConstants.ECALL_NEWOBJ) { if (i == 0) { if (!targetMethod.IsStatic) { var thisSlot = ctx.Stack[sp]; if (thisSlot.O is ValueType && !targetMethod.DeclaringType.IsValueType) { Debug.Assert(targetMethod.DeclaringType.IsInterface); Debug.Assert(opCode == DarksVMConstants.ECALL_CALLVIRT); // Interface dispatch on valuetypes => use constrained. invocation constrainType = thisSlot.O.GetType(); } } if (constrainType != null) { paramType = constrainType.MakeByRefType(); } else if (targetMethod.DeclaringType.IsValueType) { paramType = targetMethod.DeclaringType.MakeByRefType(); } else { paramType = targetMethod.DeclaringType; } } else { paramType = parameters[i - 1].ParameterType; } } else { paramType = parameters[i].ParameterType; } references[i] = PopRef(ctx, paramType, ref sp); if (paramType.IsByRef) { paramType = paramType.GetElementType(); } types[i] = paramType; } OpCode callOp; Type retType; if (opCode == DarksVMConstants.ECALL_CALL) { callOp = System.Reflection.Emit.OpCodes.Call; retType = targetMethod is MethodInfo ? ((MethodInfo)targetMethod).ReturnType : typeof(void); } else if (opCode == DarksVMConstants.ECALL_CALLVIRT || opCode == DarksVMConstants.ECALL_CALLVIRT_CONSTRAINED) { callOp = System.Reflection.Emit.OpCodes.Callvirt; retType = targetMethod is MethodInfo ? ((MethodInfo)targetMethod).ReturnType : typeof(void); } else if (opCode == DarksVMConstants.ECALL_NEWOBJ) { callOp = System.Reflection.Emit.OpCodes.Newobj; retType = targetMethod.DeclaringType; } else { throw new InvalidProgramException(); } var proxy = DirectCall.GetTypedInvocationProxy(targetMethod, callOp, constrainType); var result = proxy(ctx, references, types); if (retType != typeof(void)) { ctx.Stack[++sp] = DarksVMSlot.FromObject(result, retType); } else if (opCode == DarksVMConstants.ECALL_NEWOBJ) { ctx.Stack[++sp] = DarksVMSlot.FromObject(result, retType); } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
private BenchmarkAlgorithm(BenchmarkAlgorithm original, Cloner cloner) { if (original.ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState)); cloner.RegisterClonedObject(original, this); name = original.name; description = original.description; parameters = cloner.Clone(original.parameters); readOnlyParameters = null; executionState = original.executionState; executionTime = original.executionTime; storeAlgorithmInEachRun = original.storeAlgorithmInEachRun; runsCounter = original.runsCounter; Runs = cloner.Clone(original.runs); results = cloner.Clone(original.results); }
protected override void Dispose(bool disposing) { if (disposing) _started = ExecutionState.Stopped; base.Dispose(disposing); }
public void Execute() { try { this.OnExecute(); } catch(System.Exception exception) { this.editorExecutionState = ExecutionState.ERROR; Debug.LogException(exception); } }
protected static void FinishRequestAttempt <T>(ExecutionState <T> executionState) { executionState.Cmd.CurrentResult.EndTime = DateTime.Now; executionState.OperationContext.EndTime = DateTime.Now; Executor.FireRequestCompleted(executionState); }
/// <summary> /// Allows an application to inform the system that it /// is in use, thereby preventing the system from entering /// the sleeping power state or turning off the display /// while the application is running. /// </summary> /// <param name="flags">The thread's execution requirements.</param> /// <exception cref="Win32Exception">Thrown if the SetThreadExecutionState call fails.</exception> internal static void SetThreadExecutionState(ExecutionState flags) { ExecutionState? ret = PowerManagementNativeMethods.SetThreadExecutionState(flags); if (ret == null) throw new Win32Exception("SetThreadExecutionState call failed."); }
internal void RunInstruction(Instruction i) { switch (i.Opcode) { case OpCode.JumpTo: { /// - JumpTo /** Jumps to a named label */ state.programCounter = FindInstructionPointForLabel(i.Operands[0].StringValue) - 1; break; } case OpCode.RunLine: { /// - RunLine /** Looks up a string from the string table and * passes it to the client as a line */ string stringKey = i.Operands[0].StringValue; var pause = lineHandler(new Line(stringKey)); if (pause == Dialogue.HandlerExecutionType.PauseExecution) { executionState = ExecutionState.Suspended; } break; } case OpCode.RunCommand: { /// - RunCommand /** Passes a string to the client as a custom command */ var pause = commandHandler( new Command(i.Operands[0].StringValue) ); if (pause == Dialogue.HandlerExecutionType.PauseExecution) { executionState = ExecutionState.Suspended; } break; } case OpCode.PushString: { /// - PushString /** Pushes a string value onto the stack. The operand is an index into * the string table, so that's looked up first. */ state.PushValue(i.Operands[0].StringValue); break; } case OpCode.PushFloat: { /// - PushFloat /** Pushes a floating point onto the stack. */ state.PushValue(i.Operands[0].FloatValue); break; } case OpCode.PushBool: { /// - PushBool /** Pushes a boolean value onto the stack. */ state.PushValue(i.Operands[0].BoolValue); break; } case OpCode.PushNull: { /// - PushNull /** Pushes a null value onto the stack. */ state.PushValue(Value.NULL); break; } case OpCode.JumpIfFalse: { /// - JumpIfFalse /** Jumps to a named label if the value on the top of the stack * evaluates to the boolean value 'false'. */ if (state.PeekValue().AsBool == false) { state.programCounter = FindInstructionPointForLabel(i.Operands[0].StringValue) - 1; } break; } case OpCode.Jump: { /// - Jump /** Jumps to a label whose name is on the stack. */ var jumpDestination = state.PeekValue().AsString; state.programCounter = FindInstructionPointForLabel(jumpDestination) - 1; break; } case OpCode.Pop: { /// - Pop /** Pops a value from the stack. */ state.PopValue(); break; } case OpCode.CallFunc: { /// - CallFunc /** Call a function, whose parameters are expected to * be on the stack. Pushes the function's return value, * if it returns one. */ var functionName = i.Operands[0].StringValue; var function = dialogue.library.GetFunction(functionName); { var expectedParamCount = function.paramCount; // Expect the compiler to have placed the number of parameters // actually passed at the top of the stack. var actualParamCount = (int)state.PopValue().AsNumber; // If a function indicates -1 parameters, it takes as // many parameters as it was given (i.e. it's a // variadic function) if (expectedParamCount == -1) { expectedParamCount = actualParamCount; } if (expectedParamCount != actualParamCount) { throw new InvalidOperationException($"Function {function.name} expected {expectedParamCount}, but received {actualParamCount}"); } Value result; if (actualParamCount == 0) { result = function.Invoke(); } else { // Get the parameters, which were pushed in reverse Value[] parameters = new Value[actualParamCount]; for (int param = actualParamCount - 1; param >= 0; param--) { parameters[param] = state.PopValue(); } // Invoke the function result = function.InvokeWithArray(parameters); } // If the function returns a value, push it if (function.returnsValue) { state.PushValue(result); } } break; } case OpCode.PushVariable: { /// - PushVariable /** Get the contents of a variable, push that onto the stack. */ var variableName = i.Operands[0].StringValue; var loadedValue = dialogue.continuity.GetValue(variableName); state.PushValue(loadedValue); break; } case OpCode.StoreVariable: { /// - StoreVariable /** Store the top value on the stack in a variable. */ var topValue = state.PeekValue(); var destinationVariableName = i.Operands[0].StringValue; dialogue.continuity.SetValue(destinationVariableName, topValue); break; } case OpCode.Stop: { /// - Stop /** Immediately stop execution, and report that fact. */ nodeCompleteHandler(currentNode.Name); dialogueCompleteHandler(); executionState = ExecutionState.Stopped; break; } case OpCode.RunNode: { /// - RunNode /** Run a node */ string nodeName; if (i.Operands.Count == 0 || string.IsNullOrEmpty(i.Operands[0].StringValue)) { // Get a string from the stack, and jump to a node with that name. nodeName = state.PeekValue().AsString; } else { // jump straight to the node nodeName = i.Operands[0].StringValue; } var pause = nodeCompleteHandler(currentNode.Name); SetNode(nodeName); // Decrement program counter here, because it will // be incremented when this function returns, and // would mean skipping the first instruction state.programCounter -= 1; if (pause == Dialogue.HandlerExecutionType.PauseExecution) { executionState = ExecutionState.Suspended; } break; } case OpCode.AddOption: { /// - AddOption /** Add an option to the current state. */ if (!state.currentOptions.ContainsKey(i.Operands[0].StringValue)) { state.currentOptions.Add( i.Operands[0].StringValue, new State.OptionWithFlag( i.Operands[0].StringValue, // node name i.Operands[1].StringValue, // display string key false ) ); } break; } case OpCode.ShowOptions: { /// - ShowOptions /** If we have no options to show, immediately stop. */ if (state.currentOptions.Count == 0) { executionState = ExecutionState.Stopped; dialogueCompleteHandler(); break; } // Present the list of options to the user and let them pick var optionChoices = new List <OptionSet.Option>(); var keys = state.currentOptions.Keys.ToList(); for (int optionIndex = 0; optionIndex < keys.Count; optionIndex++) { var option = state.currentOptions[keys[optionIndex]]; var line = new Line(option.Key); if (!option.HasBeenShown) { optionChoices.Add(new OptionSet.Option(line, keys[optionIndex])); state.currentOptions[keys[optionIndex]] = new State.OptionWithFlag(option.Key, option.Value, true); } } // We can't continue until our client tell us which option to pick //executionState = ExecutionState.WaitingOnOptionSelection; // Pass the options set to the client, as well as a delegate for them to call when the // user has made a selection optionsHandler(new OptionSet(optionChoices.ToArray())); break; } default: { /// - default /** Whoa, no idea what OpCode this is. Stop the program * and throw an exception. */ executionState = ExecutionState.Stopped; throw new ArgumentOutOfRangeException( $"Unknown opcode {i.Opcode}" ); } } }
public static extern ExecutionState SetThreadExecutionState(ExecutionState esFlags);
/// Resumes execution.inheritdoc internal void Continue() { if (currentNode == null) { dialogue.LogErrorMessage("Cannot continue running dialogue. No node has been selected."); return; } if (executionState == ExecutionState.WaitingOnOptionSelection) { dialogue.LogErrorMessage("Cannot continue running dialogue. Still waiting on option selection."); return; } if (lineHandler == null) { dialogue.LogErrorMessage($"Cannot continue running dialogue. {nameof(lineHandler)} has not been set."); return; } if (optionsHandler == null) { dialogue.LogErrorMessage($"Cannot continue running dialogue. {nameof(optionsHandler)} has not been set."); return; } if (commandHandler == null) { dialogue.LogErrorMessage($"Cannot continue running dialogue. {nameof(commandHandler)} has not been set."); return; } if (nodeCompleteHandler == null) { dialogue.LogErrorMessage($"Cannot continue running dialogue. {nameof(nodeCompleteHandler)} has not been set."); return; } if (nodeCompleteHandler == null) { dialogue.LogErrorMessage($"Cannot continue running dialogue. {nameof(nodeCompleteHandler)} has not been set."); return; } executionState = ExecutionState.Running; // Execute instructions until something forces us to stop while (executionState == ExecutionState.Running) { Instruction currentInstruction = currentNode.Instructions[state.programCounter]; RunInstruction(currentInstruction); state.programCounter++; if (state.programCounter >= currentNode.Instructions.Count) { nodeCompleteHandler(currentNode.Name); executionState = ExecutionState.Stopped; dialogueCompleteHandler(); dialogue.LogDebugMessage("Run complete."); } } }
public void Stop() { executionState = ExecutionState.Stopped; }
/// <summary> /// A coroutine method that executes all commands in the Block. Only one running instance of each Block is permitted. /// </summary> /// <param name="commandIndex">Index of command to start execution at</param> /// <param name="onComplete">Delegate function to call when execution completes</param> public virtual IEnumerator Execute(int commandIndex = 0, Action onComplete = null) { if (executionState != ExecutionState.Idle) { yield break; } if (!executionInfoSet) { SetExecutionInfo(); } executionCount++; var flowchart = GetFlowchart(); executionState = ExecutionState.Executing; BlockSignals.DoBlockStart(this); #if UNITY_EDITOR // Select the executing block & the first command flowchart.SelectedBlock = this; if (commandList.Count > 0) { flowchart.ClearSelectedCommands(); flowchart.AddSelectedCommand(commandList[0]); } #endif jumpToCommandIndex = commandIndex; int i = 0; while (true) { // Executing commands specify the next command to skip to by setting jumpToCommandIndex using Command.Continue() if (jumpToCommandIndex > -1) { i = jumpToCommandIndex; jumpToCommandIndex = -1; } // Skip disabled commands, comments and labels while (i < commandList.Count && (!commandList[i].enabled || commandList[i].GetType() == typeof(Comment) || commandList[i].GetType() == typeof(Label))) { i = commandList[i].CommandIndex + 1; } if (i >= commandList.Count) { break; } // The previous active command is needed for if / else / else if commands if (activeCommand == null) { previousActiveCommandIndex = -1; } else { previousActiveCommandIndex = activeCommand.CommandIndex; } var command = commandList[i]; activeCommand = command; if (flowchart.IsActive()) { // Auto select a command in some situations if ((flowchart.SelectedCommands.Count == 0 && i == 0) || (flowchart.SelectedCommands.Count == 1 && flowchart.SelectedCommands[0].CommandIndex == previousActiveCommandIndex)) { flowchart.ClearSelectedCommands(); flowchart.AddSelectedCommand(commandList[i]); } } command.IsExecuting = true; // This icon timer is managed by the FlowchartWindow class, but we also need to // set it here in case a command starts and finishes execution before the next window update. command.ExecutingIconTimer = Time.realtimeSinceStartup + FungusConstants.ExecutingIconFadeTime; BlockSignals.DoCommandExecute(this, command, i, commandList.Count); command.Execute(); // Wait until the executing command sets another command to jump to via Command.Continue() while (jumpToCommandIndex == -1) { yield return(null); } #if UNITY_EDITOR if (flowchart.StepPause > 0f) { yield return(new WaitForSeconds(flowchart.StepPause)); } #endif command.IsExecuting = false; } executionState = ExecutionState.Idle; activeCommand = null; BlockSignals.DoBlockEnd(this); if (onComplete != null) { onComplete(); } }
private void OnRestart (object sender, RoutedEventArgs e) { this.RunButton.Click -= OnRestart; this.RunButton.Content = pausePanel; this.RunButton.Click += OnPause; execState = ExecutionState.Running; this.Dispatcher.Invoke(() => { execState = ExecutionState.Running; String st; _logProcessor.GetFirstLine(out st); }); _runTimer.Elapsed += OnTimer; _runTimer.Start(); }
protected static void FireResponseReceived <T>(ExecutionState <T> executionState) { RequestEventArgs args = GenerateRequestEventArgs <T>(executionState); executionState.OperationContext.FireResponseReceived(args); }
private void MainSlider_OnValueChangedSlider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e) { if (execState != ExecutionState.Stopped && (int)MainSlider.Value != _logProcessor.Index) { double d = MainSlider.Value; int tp = (int)d; if (tp < _logProcessor.GetAgentStartStep(_currentAgent)) { tp = _logProcessor.GetAgentStartStep(_currentAgent); //MainSlider.Value = tp; } else if (tp > LogProcessor.GetAgentEndStep(_currentAgent)) { tp = LogProcessor.GetAgentEndStep(_currentAgent); //MainSlider.Value = tp; } Task.Factory.StartNew(() => { lock (_lockerLogProcessorIndex) { if (_logProcessor.GetNumber < tp || tp < 0) { this.Dispatcher.Invoke(() => { StatusLabel.Foreground = new SolidColorBrush(Colors.Red); StatusLabel.Content = "Illegal step number!"; _statusTime = DateTime.Now; }); return; } //ast = null; isFirstLine = true; _move_to = tp; if (execState != ExecutionState.Moving) { _previousState = execState; execState = ExecutionState.Moving; } } }); } }
protected static void FireRetrying <T>(ExecutionState <T> executionState) { RequestEventArgs args = GenerateRequestEventArgs <T>(executionState); executionState.OperationContext.FireRetrying(args); }
public BatchRun(string name, string description) : base(name, description) { executionState = ExecutionState.Stopped; executionTime = TimeSpan.Zero; runsExecutionTime = TimeSpan.Zero; repetitions = 10; repetitionsCounter = 0; Runs = new RunCollection { OptimizerName = Name }; }
// Block开始执行命令 /// <summary> /// A coroutine method that executes all commands in the Block. Only one running instance of each Block is permitted. /// </summary> /// <param name="commandIndex">Index of command to start execution at</param> /// <param name="onComplete">Delegate function to call when execution completes</param> public virtual IEnumerator Execute(int commandIndex = 0, Action onComplete = null) { if (executionState != ExecutionState.Idle) { Debug.LogWarning(BlockName + " cannot be executed, it is already running."); yield break; } // 结束回调 lastOnCompleteAction = onComplete; if (!executionInfoSet) { // 设置Block下的各个Command SetExecutionInfo(); } // 此Block运行了几次 executionCount++; var executionCountAtStart = executionCount; var flowchart = GetFlowchart(); // 设置为执行状态 executionState = ExecutionState.Executing; BlockSignals.DoBlockStart(this); #if UNITY_EDITOR // Select the executing block & the first command flowchart.SelectedBlock = this; if (commandList.Count > 0) { flowchart.ClearSelectedCommands(); flowchart.AddSelectedCommand(commandList[0]); } #endif // 要执行哪个命令 jumpToCommandIndex = commandIndex; int i = 0; while (true) { // 从jumpToCommandIndex确定, 下一个要执行的命令 // Executing commands specify the next command to skip to by setting jumpToCommandIndex using Command.Continue() // 把jumpToCommandIndex传给i // * i: 真正要执行的命令index if (jumpToCommandIndex > -1) { i = jumpToCommandIndex; jumpToCommandIndex = -1; } // 跳过, // 注释命令,Label命令 // Skip disabled commands, comments and labels while (i < commandList.Count && (!commandList[i].enabled || commandList[i].GetType() == typeof(Comment) || commandList[i].GetType() == typeof(Label))) { i = commandList[i].CommandIndex + 1; } // 到达命令队列末尾 if (i >= commandList.Count) { break; } // 记录, // 前一个命令的index // The previous active command is needed for if / else / else if commands if (activeCommand == null) { previousActiveCommandIndex = -1; } else { previousActiveCommandIndex = activeCommand.CommandIndex; } // 获取到, // 要执行的命令 var command = commandList[i]; activeCommand = command; if (flowchart.IsActive()) { // Q: SelectedCommands是? // Auto select a command in some situations if ((flowchart.SelectedCommands.Count == 0 && i == 0) || (flowchart.SelectedCommands.Count == 1 && flowchart.SelectedCommands[0].CommandIndex == previousActiveCommandIndex)) { flowchart.ClearSelectedCommands(); flowchart.AddSelectedCommand(commandList[i]); } } // 标记命令执行 command.IsExecuting = true; // This icon timer is managed by the FlowchartWindow class, but we also need to // set it here in case a command starts and finishes execution before the next window update. command.ExecutingIconTimer = Time.realtimeSinceStartup + FungusConstants.ExecutingIconFadeTime; // 发送消息 BlockSignals.DoCommandExecute(this, command, i, commandList.Count); // 执行命令 command.Execute(); // 等待Continue()被调用 // Wait until the executing command sets another command to jump to via Command.Continue() while (jumpToCommandIndex == -1) { yield return(null); } #if UNITY_EDITOR if (flowchart.StepPause > 0f) { yield return(new WaitForSeconds(flowchart.StepPause)); } #endif command.IsExecuting = false; } // 只有2个状态 // * 空闲和执行中 if (State == ExecutionState.Executing && //ensure we aren't dangling from a previous stopage and stopping a future run executionCountAtStart == executionCount) { // 结束执行 // * 回到空闲状态 ReturnToIdle(); } }
public void Stop() { if (_started != ExecutionState.Running) return; //??just ignore. why explode? lock (_preQueue) { _started = ExecutionState.Created; } }
/// <summary> /// Executes the batch text given the text span /// </summary> /// <param name="batchScript"></param> /// <param name="textSpan"></param> /// <param name="continueProcessing"></param> private void ExecuteBatchTextSpanInternal(string batchScript, TextSpan textSpan, out bool continueProcessing) { Debug.Assert(!String.IsNullOrEmpty(batchScript)); continueProcessing = true; if (batchScript.Trim().Length <= 0) { result |= ScriptExecutionResult.Success; return; } Debug.Assert(currentBatch != null); if (executionState == ExecutionState.Cancelling) { result = ScriptExecutionResult.Cancel; } else { currentBatch.Reset(); currentBatch.Text = batchScript; currentBatch.TextSpan = textSpan; currentBatch.BatchIndex = currentBatchIndex; currentBatch.ExpectedExecutionCount = numBatchExecutionTimes; currentBatchIndex++; if (conditions != null) { currentBatch.IsSuppressProviderMessageHeaders = conditions.IsSuppressProviderMessageHeaders; // TODO this is associated with Dacfx specific situations, so uncomment if need be //currentBatch.IsScriptExecutionTracked = conditions.IsScriptExecutionTracked; if (conditions.IsScriptExecutionTracked) { currentBatch.ScriptTrackingId = scriptTrackingId++; } } //ExecutingBatch state means currentBatch is valid to use from another thread to Cancel executionState = ExecutionState.ExecutingBatch; } ScriptExecutionResult batchResult = ScriptExecutionResult.Failure; if (result != ScriptExecutionResult.Cancel) { bool isExecutionDiscarded = false; try { RaiseBatchParserExecutionStarted(currentBatch, textSpan); if (!isLocalParse) { batchResult = DoBatchExecution(currentBatch); } else { batchResult = ScriptExecutionResult.Success; } } finally { isExecutionDiscarded = (executionState == ExecutionState.Discarded); if (executionState == ExecutionState.Cancelling || isExecutionDiscarded) { batchResult = ScriptExecutionResult.Cancel; } else { executionState = ExecutionState.Executing; } } if (!isExecutionDiscarded) { RaiseBatchParserExecutionFinished(currentBatch, batchResult); } } else { batchResult = ScriptExecutionResult.Cancel; } //if we're in Cancel or Halt state, do some special actions if (batchResult == ScriptExecutionResult.Cancel || batchResult == ScriptExecutionResult.Halted) { result = batchResult; continueProcessing = false; return; } else { result |= batchResult; } }
public virtual void Dispose() { _state = ExecutionState.Stopped; _scheduler.Dispose(); _subscriptions.Dispose(); }
/// <summary> /// Executes the script (on a separated thread) /// </summary> private void DoExecute(bool isBatchParser) { //we should not be in the middle of execution here if (executionState == ExecutionState.Executing || executionState == ExecutionState.ExecutingBatch) { throw new InvalidOperationException(SR.EE_ExecutionNotYetCompleteError); } executionState = ExecutionState.Initial; result = ScriptExecutionResult.Failure; currentBatchIndex = 0; currentBatch.ExecutionTimeout = executionTimeout; expectedShowPlan = ShowPlanType.None; if (!isLocalParse) { errorAction = conditions.IsHaltOnError ? OnErrorAction.Exit : OnErrorAction.Ignore; CreatePrePostConditionBatches(); } ConfigureBatchEventHandlers(currentBatch, batchEventHandlers, true); // do we have a cancel request already? lock (stateSyncLock) { if (executionState == ExecutionState.Cancelling) { RaiseScriptExecutionFinished(ScriptExecutionResult.Cancel); return; } Debug.Assert(executionState == ExecutionState.Initial); executionState = ExecutionState.Executing; } if ((result = ExecutePrePostConditionBatches(preConditionBatches)) == ScriptExecutionResult.Success) { DoScriptExecution(isBatchParser); } if (!CheckForDiscardedConnection()) { if (!isLocalParse) { if (conditions.IsTransactionWrapped && !conditions.IsParseOnly) { if (result == ScriptExecutionResult.Success) { postConditionBatches.Add(new Batch(ExecutionEngineConditions.CommitTransactionStatement, false, executionTimeout)); } else { postConditionBatches.Add(new Batch(ExecutionEngineConditions.RollbackTransactionStatement, false, executionTimeout)); } } // no need to update the result value as it has been updated by the DoScriptExecution() ExecutePrePostConditionBatches(postConditionBatches); } //fire an event that we're done with execution of all batches if (result == ScriptExecutionResult.Halted) //remap into failure { result = ScriptExecutionResult.Failure; } RaiseScriptExecutionFinished(result); } }
public async Task StreamWriteAsyncTestMaxLengthBoundary() { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); MemoryStream stream1 = new MemoryStream(buffer); MemoryStream stream2 = new MemoryStream(); OperationContext tempOperationContext = new OperationContext(); RESTCommand<NullType> cmd = new RESTCommand<NullType>(TestBase.StorageCredentials, null); ExecutionState<NullType> tempExecutionState = new ExecutionState<NullType>(cmd, null, tempOperationContext); // Test write with exact number of bytes await stream1.WriteToAsync(stream2, null, stream1.Length, false, tempExecutionState, null, CancellationToken.None); stream1.Position = 0; TestHelper.AssertStreamsAreEqual(stream1, stream2); stream2.Dispose(); stream2 = new MemoryStream(); // Test write with one less byte await TestHelper.ExpectedExceptionAsync<InvalidOperationException>( async () => await stream1.WriteToAsync(stream2, null, stream1.Length - 1, false, tempExecutionState, null, CancellationToken.None), "Stream is longer than the allowed length."); stream1.Position = 0; stream2.Dispose(); stream2 = new MemoryStream(); // Test with count greater than length await stream1.WriteToAsync(stream2, null, stream1.Length + 1, false, tempExecutionState, null, CancellationToken.None); stream1.Position = 0; // Entire stream should have been copied TestHelper.AssertStreamsAreEqual(stream1, stream2); stream1.Dispose(); stream2.Dispose(); }
public override void VisitEndMethodDeclaration(VBSyntax.MethodBlockSyntax node, ExecutionState state) { CheckState(state); }
public override void VisitEnd(SyntaxNode node, ExecutionState state) { CheckState(state); }
public object EvaluateVariableProperty(string propertyName, Token propertyToken, ExecutionState state) { switch (propertyName) { case "forumcategoryid": return(forumCategory.ForumCategoryID); case "clientspaceid": return(forumCategory.ClientSpaceID); case "categorycode": return(forumCategory.CategoryCode); case "name": return(forumCategory.Name); case "urltoken": return(forumCategory.URLToken); case "datecreated": return(forumCategory.DateCreated); case "rank": return(forumCategory.Rank); case "internaluseonly": return(forumCategory.InternalUseOnly); case "forumlist": return(GetForums()); default: throw new InstructionExecutionException("\"" + propertyName + "\" is not a property of this variable.", propertyToken); } }
/// <summary> /// Stop consuming actions. /// </summary> public void Stop() { _timer.Dispose(); _started = ExecutionState.Stopped; _subscriptions.Dispose(); }
public object Evaluate(ExecutionState state, Token contextToken) { return("[Page: " + pageID + "]"); }
private void OnPause(object sender, RoutedEventArgs e) { this.RunButton.Click -= OnPause; execState = ExecutionState.Paused; this.RunButton.Content = runIcon; this.RunButton.Click += OnRun; _runTimer.Elapsed -= OnTimer; _runTimer.Stop(); }
internal static extern uint SetThreadExecutionState(ExecutionState state);
private void OnStop(object sender, RoutedEventArgs e) { if (execState == ExecutionState.Running) { this.RunButton.Content = runIcon; this.RunButton.Click -= OnPause; } else if (execState == ExecutionState.Paused) { this.RunButton.Click -= OnRun; } this.RunButton.Click += OnRestart; if (execState == ExecutionState.Paused || execState == ExecutionState.Running) { if (execState == ExecutionState.Running) {_runTimer.Elapsed -= OnTimer;} execState = ExecutionState.Void; _runTimer.Stop(); this.Dispatcher.Invoke(() => { String st; _logProcessor.GetLastLine(out st); }); } }
internal static void WriteToAsync <T>(this Stream stream, Stream toStream, long?copyLength, long?maxLength, bool calculateMd5, ExecutionState <T> executionState, StreamDescriptor streamCopyState, Action <ExecutionState <T> > completed) { AsyncStreamCopier <T> copier = new AsyncStreamCopier <T>(stream, toStream, executionState, GetBufferSize(stream), calculateMd5, streamCopyState); copier.StartCopyStream(completed, copyLength, maxLength); }
private void UIElement_OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e) { var item = (sender as Grid); Agent tp = (Agent)item.DataContext; if (Keyboard.Modifiers.ToString().Contains("Control")) { if (tp.ID == _currentAgent) { this.Dispatcher.Invoke(() => { StatusLabel.Foreground = new SolidColorBrush(Colors.Red); StatusLabel.Content = "This is actually the current agent."; _statusTime = DateTime.Now; }); } else if (_logProcessor.IsAgentLogAvailable(tp.ID)) { _currentAgent = tp.ID; _logProcessor.CurrentAgent = _currentAgent; _previousState = execState; execState = ExecutionState.Switching; } else { this.Dispatcher.Invoke(() => { StatusLabel.Foreground = new SolidColorBrush(Colors.Red); StatusLabel.Content = "Agent #" + tp.ID + " doesn't have the log file"; _statusTime = DateTime.Now; }); } } else { tp.IsExpanded = !tp.IsExpanded; } }
internal static void WriteToSync <T>(this Stream stream, Stream toStream, long?copyLength, long?maxLength, bool calculateMd5, bool syncRead, ExecutionState <T> executionState, StreamDescriptor streamCopyState) { if (copyLength.HasValue && maxLength.HasValue) { throw new ArgumentException(SR.StreamLengthMismatch); } if (stream.CanSeek && maxLength.HasValue && stream.Length - stream.Position > maxLength) { throw new InvalidOperationException(SR.StreamLengthError); } if (stream.CanSeek && copyLength.HasValue && stream.Length - stream.Position < copyLength) { throw new ArgumentOutOfRangeException("copyLength", SR.StreamLengthShortError); } byte[] buffer = new byte[GetBufferSize(stream)]; if (streamCopyState != null && calculateMd5 && streamCopyState.Md5HashRef == null) { streamCopyState.Md5HashRef = new MD5Wrapper(); } RegisteredWaitHandle waitHandle = null; ManualResetEvent completedEvent = null; if (!syncRead && executionState.OperationExpiryTime.HasValue) { completedEvent = new ManualResetEvent(false); waitHandle = ThreadPool.RegisterWaitForSingleObject( completedEvent, StreamExtensions.MaximumCopyTimeCallback <T>, executionState, executionState.RemainingTimeout, true); } try { long?bytesRemaining = copyLength; int readCount; do { if (executionState.OperationExpiryTime.HasValue && DateTime.Now.CompareTo(executionState.OperationExpiryTime.Value) > 0) { throw Exceptions.GenerateTimeoutException(executionState.Cmd != null ? executionState.Cmd.CurrentResult : null, null); } // Determine how many bytes to read this time so that no more than copyLength bytes are read int bytesToRead = MinBytesToRead(bytesRemaining, buffer.Length); if (bytesToRead == 0) { break; } // Read synchronously or asynchronously readCount = syncRead ? stream.Read(buffer, 0, bytesToRead) : stream.EndRead(stream.BeginRead(buffer, 0, bytesToRead, null /* Callback */, null /* State */)); // Decrement bytes to write from bytes read if (bytesRemaining.HasValue) { bytesRemaining -= readCount; } // Write if (readCount > 0) { toStream.Write(buffer, 0, readCount); // Update the StreamDescriptor after the bytes are successfully committed to the output stream if (streamCopyState != null) { streamCopyState.Length += readCount; if (maxLength.HasValue && streamCopyState.Length > maxLength.Value) { throw new InvalidOperationException(SR.StreamLengthError); } if (streamCopyState.Md5HashRef != null) { streamCopyState.Md5HashRef.UpdateHash(buffer, 0, readCount); } } } }while (readCount != 0); if (bytesRemaining.HasValue && bytesRemaining != 0) { throw new ArgumentOutOfRangeException("copyLength", SR.StreamLengthShortError); } } catch (Exception) { if (executionState.OperationExpiryTime.HasValue && DateTime.Now.CompareTo(executionState.OperationExpiryTime.Value) > 0) { throw Exceptions.GenerateTimeoutException(executionState.Cmd != null ? executionState.Cmd.CurrentResult : null, null); } else { throw; } } finally { if (waitHandle != null) { waitHandle.Unregister(null); } if (completedEvent != null) { completedEvent.Close(); } } if (streamCopyState != null && streamCopyState.Md5HashRef != null) { streamCopyState.Md5 = streamCopyState.Md5HashRef.ComputeHash(); streamCopyState.Md5HashRef = null; } }
public BatchRun() : base() { name = ItemName; description = ItemDescription; executionState = ExecutionState.Stopped; executionTime = TimeSpan.Zero; runsExecutionTime = TimeSpan.Zero; repetitions = 10; repetitionsCounter = 0; Runs = new RunCollection { OptimizerName = Name }; }
public bool Intersects(ExecutionState <G> executionState) { return(true); }
private BatchRun(BatchRun original, Cloner cloner) : base(original, cloner) { executionState = original.executionState; executionTime = original.executionTime; runsExecutionTime = original.runsExecutionTime; optimizer = cloner.Clone(original.optimizer); repetitions = original.repetitions; repetitionsCounter = original.repetitionsCounter; runs = cloner.Clone(original.runs); batchRunAction = original.batchRunAction; Initialize(); }
private void SetState(ExecutionState state) { this._state = state; }
public void Start() { if (_started == ExecutionState.Running) return; //??just ignore. why explode? InternalStart(); lock (_preQueue) { if (_preQueue.Count > 0) InternalEnqueue(() => Executor.Execute(_preQueue)); _started = ExecutionState.Running; } }
public void Step(ExecutionFrame frame, Stack <VMObject> stack) { try { var opcode = (Opcode)Read8(); frame.VM.ValidateOpcode(opcode); switch (opcode) { case Opcode.NOP: { break; } // args: byte src_reg, byte dest_reg case Opcode.MOVE: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); frame.Registers[dst] = frame.Registers[src]; break; } // args: byte src_reg, byte dest_reg case Opcode.COPY: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); frame.Registers[dst].Copy(frame.Registers[src]); break; } // args: byte dst_reg, byte type, var length, var data_bytes case Opcode.LOAD: { var dst = Read8(); var type = (VMType)Read8(); var len = (int)ReadVar(0xFFFF); Expect(dst < frame.Registers.Length); var bytes = ReadBytes(len); frame.Registers[dst].SetValue(bytes, type); break; } // args: byte src_reg, dst_reg, byte type case Opcode.CAST: { var src = Read8(); var dst = Read8(); var type = (VMType)Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var val = frame.Registers[src]; val = VMObject.CastTo(val, type); frame.Registers[dst] = val; break; } // args: byte src_reg case Opcode.PUSH: { var src = Read8(); Expect(src < frame.Registers.Length); var val = frame.Registers[src]; var temp = new VMObject(); temp.Copy(val); stack.Push(temp); break; } // args: byte dest_reg case Opcode.POP: { var dst = Read8(); Expect(stack.Count > 0); Expect(dst < frame.Registers.Length); frame.Registers[dst] = stack.Pop(); break; } // args: byte src_reg, byte dest_reg case Opcode.SWAP: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var temp = frame.Registers[src]; frame.Registers[src] = frame.Registers[dst]; frame.Registers[dst] = temp; break; } // args: ushort offset, byte regCount case Opcode.CALL: { var count = Read8(); var ofs = Read16(); Expect(ofs < this.Script.Length); Expect(count >= 1); Expect(count <= VirtualMachine.MaxRegisterCount); frame.VM.PushFrame(this, InstructionPointer, count); InstructionPointer = ofs; break; } // args: byte srcReg case Opcode.EXTCALL: { var src = Read8(); Expect(src < frame.Registers.Length); var method = frame.Registers[src].AsString(); var state = frame.VM.ExecuteInterop(method); if (state != ExecutionState.Running) { throw new VMException(frame.VM, "VM extcall failed: " + method); } break; } // args: ushort offset, byte src_reg // NOTE: JMP only has offset arg, not the rest case Opcode.JMP: case Opcode.JMPIF: case Opcode.JMPNOT: { bool shouldJump; if (opcode == Opcode.JMP) { shouldJump = true; } else { var src = Read8(); Expect(src < frame.Registers.Length); shouldJump = frame.Registers[src].AsBool(); if (opcode == Opcode.JMPNOT) { shouldJump = !shouldJump; } } var newPos = (short)Read16(); Expect(newPos >= 0); Expect(newPos < this.Script.Length); if (shouldJump) { InstructionPointer = (uint)newPos; } break; } // args: var length, var bytes case Opcode.THROW: { var len = (int)ReadVar(1024); if (len > 0) { var bytes = ReadBytes(len); } SetState(ExecutionState.Fault); return; } // args: none case Opcode.RET: { if (frame.VM.frames.Count > 1) { var temp = frame.VM.PeekFrame(); if (temp.Context == this) { InstructionPointer = frame.VM.PopFrame(); //Expect(InstructionPointer == this.Script.Length); } else { SetState(ExecutionState.Halt); } } else { SetState(ExecutionState.Halt); } return; } // args: byte src_a_reg, byte src_b_reg, byte dest_reg case Opcode.CAT: { var srcA = Read8(); var srcB = Read8(); var dst = Read8(); Expect(srcA < frame.Registers.Length); Expect(srcB < frame.Registers.Length); Expect(dst < frame.Registers.Length); var A = frame.Registers[srcA]; var B = frame.Registers[srcB]; if (!A.IsEmpty) { if (B.IsEmpty) { frame.Registers[dst].Copy(A); } else { var bytesA = A.AsByteArray(); var bytesB = B.AsByteArray(); var result = new byte[bytesA.Length + bytesB.Length]; Array.Copy(bytesA, result, bytesA.Length); Array.Copy(bytesB, 0, result, bytesA.Length, bytesB.Length); Expect(A.Type == B.Type); VMType type = A.Type; frame.Registers[dst].SetValue(result, type); } } else { if (B.IsEmpty) { frame.Registers[dst] = new VMObject(); } else { frame.Registers[dst].Copy(B); } } break; } case Opcode.SUBSTR: { throw new NotImplementedException(); } // args: byte src_reg, byte dest_reg, var length case Opcode.LEFT: { var src = Read8(); var dst = Read8(); var len = (int)ReadVar(0xFFFF); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var src_array = frame.Registers[src].AsByteArray(); Expect(len <= src_array.Length); var result = new byte[len]; Array.Copy(src_array, result, len); frame.Registers[dst].SetValue(result, VMType.Bytes); break; } // args: byte src_reg, byte dest_reg, byte length case Opcode.RIGHT: { var src = Read8(); var dst = Read8(); var len = (int)ReadVar(0xFFFF); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var src_array = frame.Registers[src].AsByteArray(); Expect(len <= src_array.Length); var ofs = src_array.Length - len; var result = new byte[len]; Array.Copy(src_array, ofs, result, 0, len); frame.Registers[dst].SetValue(result, VMType.Bytes); break; } // args: byte src_reg, byte dest_reg case Opcode.SIZE: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var src_array = frame.Registers[src].AsByteArray(); frame.Registers[dst].SetValue(src_array.Length); break; } // args: byte src_reg, byte dest_reg case Opcode.COUNT: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var val = frame.Registers[src]; int count; switch (val.Type) { case VMType.Struct: { var children = val.GetChildren(); count = children.Count; break; } default: count = 1; break; } frame.Registers[dst].SetValue(count); break; } // args: byte src_reg, byte dest_reg case Opcode.NOT: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var val = frame.Registers[src].AsBool(); frame.Registers[dst].SetValue(!val); break; } // args: byte src_a_reg, byte src_b_reg, byte dest_reg case Opcode.AND: case Opcode.OR: case Opcode.XOR: { var srcA = Read8(); var srcB = Read8(); var dst = Read8(); Expect(srcA < frame.Registers.Length); Expect(srcB < frame.Registers.Length); Expect(dst < frame.Registers.Length); var a = frame.Registers[srcA].AsBool(); var b = frame.Registers[srcB].AsBool(); bool result; switch (opcode) { case Opcode.AND: result = (a && b); break; case Opcode.OR: result = (a || b); break; case Opcode.XOR: result = (a ^ b); break; default: { SetState(ExecutionState.Fault); return; } } frame.Registers[dst].SetValue(result); break; } // args: byte src_a_reg, byte src_b_reg, byte dest_reg case Opcode.EQUAL: { var srcA = Read8(); var srcB = Read8(); var dst = Read8(); Expect(srcA < frame.Registers.Length); Expect(srcB < frame.Registers.Length); Expect(dst < frame.Registers.Length); var a = frame.Registers[srcA]; var b = frame.Registers[srcB]; var result = a.Equals(b); frame.Registers[dst].SetValue(result); break; } // args: byte src_a_reg, byte src_b_reg, byte dest_reg case Opcode.LT: case Opcode.GT: case Opcode.LTE: case Opcode.GTE: { var srcA = Read8(); var srcB = Read8(); var dst = Read8(); Expect(srcA < frame.Registers.Length); Expect(srcB < frame.Registers.Length); Expect(dst < frame.Registers.Length); var a = frame.Registers[srcA].AsNumber(); var b = frame.Registers[srcB].AsNumber(); bool result; switch (opcode) { case Opcode.LT: result = (a < b); break; case Opcode.GT: result = (a > b); break; case Opcode.LTE: result = (a <= b); break; case Opcode.GTE: result = (a >= b); break; default: { SetState(ExecutionState.Fault); return; } } frame.Registers[dst].SetValue(result); break; } // args: byte reg case Opcode.INC: { var dst = Read8(); Expect(dst < frame.Registers.Length); var val = frame.Registers[dst].AsNumber(); frame.Registers[dst].SetValue(val + 1); break; } // args: byte reg case Opcode.DEC: { var dst = Read8(); Expect(dst < frame.Registers.Length); var val = frame.Registers[dst].AsNumber(); frame.Registers[dst].SetValue(val - 1); break; } // args: byte src_reg, byte dest_reg case Opcode.SIGN: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var val = frame.Registers[src].AsNumber(); if (val == 0) { frame.Registers[dst].SetValue(BigInteger.Zero); } else { frame.Registers[dst].SetValue(val < 0 ? -1 : 1); } break; } // args: byte src_reg, byte dest_reg case Opcode.NEGATE: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var val = frame.Registers[src].AsNumber(); frame.Registers[dst].SetValue(-val); break; } // args: byte src_reg, byte dest_reg case Opcode.ABS: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var val = frame.Registers[src].AsNumber(); frame.Registers[dst].SetValue(val < 0 ? -val : val); break; } // args: byte src_a_reg, byte src_b_reg, byte dest_reg case Opcode.ADD: case Opcode.SUB: case Opcode.MUL: case Opcode.DIV: case Opcode.MOD: case Opcode.SHR: case Opcode.SHL: case Opcode.MIN: case Opcode.MAX: { var srcA = Read8(); var srcB = Read8(); var dst = Read8(); Expect(srcA < frame.Registers.Length); Expect(srcB < frame.Registers.Length); Expect(dst < frame.Registers.Length); var a = frame.Registers[srcA].AsNumber(); var b = frame.Registers[srcB].AsNumber(); BigInteger result; switch (opcode) { case Opcode.ADD: result = a + b; break; case Opcode.SUB: result = a - b; break; case Opcode.MUL: result = a * b; break; case Opcode.DIV: result = a / b; break; case Opcode.MOD: result = a % b; break; case Opcode.SHR: result = a >> (int)b; break; case Opcode.SHL: result = a << (int)b; break; case Opcode.MIN: result = a < b ? a : b; break; case Opcode.MAX: result = a > b ? a : b; break; default: { SetState(ExecutionState.Fault); return; } } frame.Registers[dst].SetValue(result); break; } // args: byte src_reg, byte dest_reg, byte key case Opcode.PUT: { var src = Read8(); var dst = Read8(); var keyReg = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); Expect(keyReg < frame.Registers.Length); var key = frame.Registers[keyReg]; var value = frame.Registers[src]; frame.Registers[dst].SetKey(key, value); break; } // args: byte src_reg, byte dest_reg, byte key case Opcode.GET: { var src = Read8(); var dst = Read8(); var keyReg = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); Expect(keyReg < frame.Registers.Length); var key = frame.Registers[keyReg]; var val = frame.Registers[src].GetKey(key); frame.Registers[dst] = val; break; } // args: byte dest_reg case Opcode.THIS: { var dst = Read8(); Expect(dst < frame.Registers.Length); frame.Registers[dst].SetValue(this); break; } // args: byte dest_reg, var key case Opcode.CTX: { var src = Read8(); var dst = Read8(); Expect(src < frame.Registers.Length); Expect(dst < frame.Registers.Length); var contextName = frame.Registers[src].AsString(); ExecutionContext context = frame.VM.FindContext(contextName); if (context == null) { throw new VMException(frame.VM, $"VM ctx instruction failed: could not find context with name '{contextName}'"); } frame.Registers[dst].SetValue(context); break; } // args: byte src_reg case Opcode.SWITCH: { var src = Read8(); Expect(src < frame.Registers.Length); var context = frame.Registers[src].AsInterop <ExecutionContext>(); _state = frame.VM.SwitchContext(context, InstructionPointer); if (_state == ExecutionState.Halt) { _state = ExecutionState.Running; frame.VM.PopFrame(); } else { throw new VMException(frame.VM, $"VM switch instruction failed: execution state did not halt"); } break; } default: { throw new VMException(frame.VM, $"Unknown VM opcode: {(int)opcode}"); } } } catch (Exception ex) { if (ex is TargetInvocationException) { ex = ((TargetInvocationException)ex).InnerException; } Trace.WriteLine(ex.ToString()); SetState(ExecutionState.Fault); if (!(ex is VMException)) { ex = new VMException(frame.VM, ex.Message); } if (frame.VM.ThrowOnFault) // enable this when debugging difficult stuff in the VM, should not be activated for production code { throw ex; } } }
public void EditorUpdate() { this.m_editorTimeDelta += Time.deltaTime; if(this.m_editorTimeDelta >= this.m_editorStateResetTime) { this.m_editorTimeDelta = 0; if(editorExecutionState != ExecutionState.ERROR) { editorExecutionState = ExecutionState.IDLE; } } this.OnShowHideInHierarchy(); this.OnEditorUpdate(); foreach(Anchor anchor in anchors) { anchor.EditorUpdate(); } }
private static extern ExecutionState SetThreadExecutionState(ExecutionState esFlags);
/// <summary> /// Invokes the exposed method by name, if successful /// will invoke all nodes connected via the anchor by the same /// name. /// </summary> /// <param name="methodName"></param> public void Fire(string methodName, params object[] args) { try { foreach(Expose exposed in GetExposed()) { if(exposed.exposedName == methodName) { FireExposed(exposed); } } } catch(System.Exception exception) { this.editorExecutionState = ExecutionState.ERROR; Debug.LogException(exception); } }
public static void Execute <G>(this Instruction <G> instruction, IInstructionExecutor <G> executor, ExecutionState <G> executionState, StackList <ValuePointer <G> > stackRegister, StackList <StackValuePointer <G> > stackPointers) where G : IGroupState <G>, new() { instruction.ExecutionBody(executor, executionState, instruction.Payload, stackRegister, stackPointers); }
protected Executable() { executionState = ExecutionState.Stopped; executionTime = TimeSpan.Zero; }
public ICancellableAsyncResult BeginUploadFromStream(Stream source, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtils.AssertNotNull("source", source); this.attributes.AssertNoSnapshot(); if (!source.CanSeek) { throw new InvalidOperationException(); } long size = source.Length - source.Position; if ((size % Constants.PageSize) != 0) { throw new ArgumentException(SR.InvalidPageSize, "source"); } BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient); DateTime? expiryTime = modifiedOptions.MaximumExecutionTime.HasValue ? DateTime.Now + modifiedOptions.MaximumExecutionTime.Value : (DateTime?)null; OperationContext tempOperationContext = new OperationContext(); ExecutionState<NullType> executionState = new ExecutionState<NullType>(null /* cmd */, modifiedOptions.RetryPolicy, tempOperationContext); ChainedAsyncResult<NullType> chainedResult = new ChainedAsyncResult<NullType>(callback, state); lock (chainedResult.CancellationLockerObject) { ICancellableAsyncResult result = this.BeginOpenWrite( size, accessCondition, modifiedOptions, operationContext, ar => { chainedResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); lock (chainedResult.CancellationLockerObject) { chainedResult.CancelDelegate = null; try { Stream blobStream = this.EndOpenWrite(ar); source.WriteToAsync( blobStream, null /* maxLength */, expiryTime, false, executionState, tempOperationContext, null /* streamCopyState */, completedState => { chainedResult.UpdateCompletedSynchronously(executionState.CompletedSynchronously); try { blobStream.Close(); chainedResult.OnComplete(executionState.ExceptionRef); } catch (Exception e) { chainedResult.OnComplete(e); } }); chainedResult.CancelDelegate = executionState.Cancel; if (chainedResult.CancelRequested) { chainedResult.Cancel(); } } catch (Exception e) { chainedResult.OnComplete(e); } } }, null /* state */); chainedResult.CancelDelegate = result.Cancel; if (chainedResult.CancelRequested) { chainedResult.Cancel(); } } return chainedResult; }
public BenchmarkAlgorithm() { name = ItemName; description = ItemDescription; parameters = new ParameterCollection(); readOnlyParameters = null; executionState = ExecutionState.Stopped; executionTime = TimeSpan.Zero; storeAlgorithmInEachRun = false; runsCounter = 0; Runs = new RunCollection() { OptimizerName = name }; results = new ResultCollection(); CreateParameters(); DiscoverBenchmarks(); Prepare(); }
extern static ExecutionState SetThreadExecutionState(ExecutionState esFlags);
protected Executable(Executable original, Cloner cloner) : base(original, cloner) { executionState = original.executionState; executionTime = original.executionTime; }
private void InvokeNormal(DarksVMContext ctx, MethodBase targetMethod, byte opCode, ref uint sp, out ExecutionState state) { var _sp = sp; var parameters = targetMethod.GetParameters(); object self = null; var args = new object[parameters.Length]; if (opCode == DarksVMConstants.ECALL_CALL && targetMethod.IsVirtual) { var indexOffset = targetMethod.IsStatic ? 0 : 1; args = new object[parameters.Length + indexOffset]; for (var i = parameters.Length - 1; i >= 0; i--) { args[i + indexOffset] = PopObject(ctx, parameters[i].ParameterType, ref sp); } if (!targetMethod.IsStatic) { args[0] = PopObject(ctx, targetMethod.DeclaringType, ref sp); } targetMethod = DirectCall.GetDirectInvocationProxy(targetMethod); } else { args = new object[parameters.Length]; for (var i = parameters.Length - 1; i >= 0; i--) { args[i] = PopObject(ctx, parameters[i].ParameterType, ref sp); } if (!targetMethod.IsStatic && opCode != DarksVMConstants.ECALL_NEWOBJ) { self = PopObject(ctx, targetMethod.DeclaringType, ref sp); if (self != null && !targetMethod.DeclaringType.IsInstanceOfType(self)) { // ConfuserEx sometimes produce this to circumvent peverify (see ref proxy) // Reflection won't allow it, so use typed invoke InvokeTyped(ctx, targetMethod, opCode, ref _sp, out state); return; } } } object result; if (opCode == DarksVMConstants.ECALL_NEWOBJ) { try { result = ((ConstructorInfo)targetMethod).Invoke(args); } catch (TargetInvocationException ex) { EHHelper.Rethrow(ex.InnerException, null); throw; } } else { if (!targetMethod.IsStatic && self == null) { throw new NullReferenceException(); } Type selfType; if (self != null && (selfType = self.GetType()).IsArray && targetMethod.Name == "SetValue") { Type valueType; if (args[0] == null) { valueType = selfType.GetElementType(); } else { valueType = args[0].GetType(); } ArrayStoreHelpers.SetValue((Array)self, (int)args[1], args[0], valueType, selfType.GetElementType()); result = null; } else { try { result = targetMethod.Invoke(self, args); } catch (TargetInvocationException ex) { DarksVMDispatcher.DoThrow(ctx, ex.InnerException); throw; } } } if (targetMethod is MethodInfo && ((MethodInfo)targetMethod).ReturnType != typeof(void)) { ctx.Stack[++sp] = DarksVMSlot.FromObject(result, ((MethodInfo)targetMethod).ReturnType); } else if (opCode == DarksVMConstants.ECALL_NEWOBJ) { ctx.Stack[++sp] = DarksVMSlot.FromObject(result, targetMethod.DeclaringType); } ctx.Stack.SetTopPosition(sp); ctx.Registers[DarksVMConstants.REG_SP].U4 = sp; state = ExecutionState.Next; }
public ICancellableAsyncResult BeginWritePages(Stream pageData, long startOffset, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient); bool requiresContentMD5 = (contentMD5 == null) && modifiedOptions.UseTransactionalMD5.Value; operationContext = operationContext ?? new OperationContext(); ChainedAsyncResult<NullType> chainedResult = new ChainedAsyncResult<NullType>(callback, state); if (pageData.CanSeek && !requiresContentMD5) { this.WritePagesHandler(pageData, startOffset, contentMD5, accessCondition, modifiedOptions, operationContext, chainedResult); } else { DateTime? expiryTime = modifiedOptions.MaximumExecutionTime.HasValue ? DateTime.Now + modifiedOptions.MaximumExecutionTime.Value : (DateTime?)null; OperationContext tempOperationContext = new OperationContext(); ExecutionState<NullType> executionState = new ExecutionState<NullType>(null /* cmd */, modifiedOptions.RetryPolicy, tempOperationContext); chainedResult.CancelDelegate = executionState.Cancel; Stream seekableStream; Stream writeToStream; if (pageData.CanSeek) { seekableStream = pageData; writeToStream = Stream.Null; } else { seekableStream = new MemoryStream(); writeToStream = seekableStream; } long startPosition = seekableStream.Position; StreamDescriptor streamCopyState = new StreamDescriptor(); pageData.WriteToAsync( writeToStream, Constants.MaxBlockSize, expiryTime, requiresContentMD5, executionState, tempOperationContext, streamCopyState, _ => { chainedResult.UpdateCompletedSynchronously(executionState.CompletedSynchronously); if (executionState.ExceptionRef != null) { chainedResult.OnComplete(executionState.ExceptionRef); } else { try { if (requiresContentMD5) { contentMD5 = streamCopyState.Md5; } seekableStream.Position = startPosition; this.WritePagesHandler(seekableStream, startOffset, contentMD5, accessCondition, modifiedOptions, operationContext, chainedResult); } catch (Exception e) { chainedResult.OnComplete(e); } } }); } return chainedResult; }
public void WriteToMultiBufferMemoryStreamTestAPM() { using (AutoResetEvent waitHandle = new AutoResetEvent(false)) { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); MemoryStream stream1 = new MemoryStream(buffer); RESTCommand <NullType> cmd = new RESTCommand <NullType>(TestBase.StorageCredentials, null, null); ExecutionState <NullType> state = new ExecutionState <NullType>(cmd, new NoRetry(), new OperationContext()); StreamDescriptor copyState = new StreamDescriptor(); MultiBufferMemoryStream stream2 = new MultiBufferMemoryStream(null /* bufferManager */); stream1.WriteToAsync(stream2, default(IBufferManager), null, null, ChecksumRequested.None, state, copyState, CancellationToken.None, _ => waitHandle.Set()); waitHandle.WaitOne(); if (state.ExceptionRef != null) { throw state.ExceptionRef; } stream1.Seek(0, SeekOrigin.Begin); stream2.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream1, stream2); MultiBufferMemoryStream stream3 = new MultiBufferMemoryStream(null /* bufferManager */); IAsyncResult ar = stream2.BeginFastCopyTo(stream3, DateTime.Now.AddMinutes(-1), _ => waitHandle.Set(), null); waitHandle.WaitOne(); TestHelper.ExpectedException <TimeoutException>( () => stream3.EndFastCopyTo(ar), "Past expiration time should immediately fail"); stream2.Seek(0, SeekOrigin.Begin); stream3.Seek(0, SeekOrigin.Begin); ar = stream2.BeginFastCopyTo(stream3, DateTime.Now.AddHours(1), _ => waitHandle.Set(), null); waitHandle.WaitOne(); stream2.EndFastCopyTo(ar); stream2.Seek(0, SeekOrigin.Begin); stream3.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream2, stream3); MultiBufferMemoryStream stream4 = new MultiBufferMemoryStream(null, 12345); ar = stream3.BeginFastCopyTo(stream4, null, _ => waitHandle.Set(), null); waitHandle.WaitOne(); stream3.EndFastCopyTo(ar); stream3.Seek(0, SeekOrigin.Begin); stream4.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream3, stream4); state = new ExecutionState <NullType>(cmd, new NoRetry(), new OperationContext()); copyState = new StreamDescriptor(); MemoryStream stream5 = new MemoryStream(); stream4.WriteToAsync(stream5, default(IBufferManager), null, null, ChecksumRequested.None, state, copyState, CancellationToken.None, _ => waitHandle.Set()); waitHandle.WaitOne(); if (state.ExceptionRef != null) { throw state.ExceptionRef; } stream4.Seek(0, SeekOrigin.Begin); stream5.Seek(0, SeekOrigin.Begin); TestHelper.AssertStreamsAreEqual(stream4, stream5); TestHelper.AssertStreamsAreEqual(stream1, stream5); } }
private void backupWorkData(ExecutionState status, string clientURL, string jobTrackerURL, string mapperName, byte[] mapperCode, long fileSize, long totalSplits, long remainingSplits) { this.mapperName = mapperName; this.mapperCode = mapperCode; this.fileSize = fileSize; this.totalSplits = totalSplits; this.remainingSplits = remainingSplits; }
internal static Task WriteToAsync <T>(this Stream stream, Stream toStream, ExecutionState <T> executionState, CancellationToken cancellationToken) { return(new AsyncStreamCopier <T>(stream, toStream, executionState, GetBufferSize(stream)).StartCopyStream(null, null, cancellationToken)); }