/// <summary> /// Adds a transition to the <paramref name="model" />'s current state. /// </summary> /// <param name="model">The model the transition should be added for.</param> /// <param name="continuationId">The id of the transition.</param> public void Add(ExecutableModel <TExecutableModel> model, int continuationId) { if (_transitionsWithContinuationIdCount >= _capacity) { throw new OutOfMemoryException("Unable to store an additional transition. Try increasing the successor state capacity."); } // 1. Notify all fault activations, so that the correct activation is set in the run time model // (Needed to persist persistent faults) model.NotifyFaultActivations(); // 2. Serialize the model's computed state; that is the successor state of the transition's source state // _including_ any changes resulting from notifications of fault activations var successorState = _targetStateMemory + _stateVectorSize * _transitionsWithContinuationIdCount; model.Serialize(successorState); // 3. Store the transition var activatedFaults = FaultSet.FromActivatedFaults(model.NondeterministicFaults); var positionOfTransition = _transitionsWithContinuationIdCount; _transitionsWithContinuationIdMemory[positionOfTransition] = new LtmdpTransition { TargetStatePointer = successorState, Formulas = new StateFormulaSet(_formulas), ActivatedFaults = activatedFaults, Flags = TransitionFlags.IsValidFlag, Index = positionOfTransition }; ++_transitionsWithContinuationIdCount; LtmdpStepGraph.SetTargetOfFinalOrUnsplitChoice(continuationId, positionOfTransition); }
/// <summary> /// Adds a transition to the <paramref name="model" />'s current state. /// </summary> /// <param name="model">The model the transition should be added for.</param> /// <param name="probability">The probability of the transition.</param> public void Add(ExecutableModel <TExecutableModel> model, double probability) { if (_count >= _capacity) { throw new OutOfMemoryException("Unable to store an additional transition. Try increasing the successor state capacity."); } // 1. Notify all fault activations, so that the correct activation is set in the run time model // (Needed to persist persistent faults) model.NotifyFaultActivations(); // 2. Serialize the model's computed state; that is the successor state of the transition's source state // _including_ any changes resulting from notifications of fault activations var successorState = _targetStateMemory + _stateVectorSize * _count; model.Serialize(successorState); // 3. Store the transition var activatedFaults = FaultSet.FromActivatedFaults(model.NondeterministicFaults); _transitions[_count] = new LtmcTransition { TargetStatePointer = successorState, Formulas = new StateFormulaSet(_formulas), ActivatedFaults = activatedFaults, Flags = TransitionFlags.IsValidFlag, Probability = probability }; ++_count; }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="model">The model the successors are computed for.</param> /// <param name="capacity">The maximum number of successors that can be cached.</param> /// <param name="formulas">The formulas that should be checked for all successor states.</param> public ActivationMinimalTransitionSetBuilder(ExecutableModel <TExecutableModel> model, long capacity, params Func <bool>[] formulas) { Requires.NotNull(model, nameof(model)); Requires.NotNull(formulas, nameof(formulas)); Requires.That(formulas.Length < 32, "At most 32 formulas are supported."); Requires.That(capacity <= (1 << 30), nameof(capacity), $"Maximum supported capacity is {1 << 30}."); _stateVectorSize = model.StateVectorSize; _formulas = formulas; _transitionBuffer.Resize(capacity * sizeof(CandidateTransition), zeroMemory: false); _transitions = (CandidateTransition *)_transitionBuffer.Pointer; _targetStateBuffer.Resize(capacity * model.StateVectorSize, zeroMemory: true); _targetStateMemory = _targetStateBuffer.Pointer; _lookupBuffer.Resize(capacity * sizeof(int), zeroMemory: false); _faultsBuffer.Resize(capacity * sizeof(FaultSetInfo), zeroMemory: false); _hashedStateBuffer.Resize(capacity * _stateVectorSize, zeroMemory: false); _successors = new List <uint>(); _capacity = capacity; _lookup = (int *)_lookupBuffer.Pointer; _faults = (FaultSetInfo *)_faultsBuffer.Pointer; _hashedStateMemory = _hashedStateBuffer.Pointer; for (var i = 0; i < capacity; ++i) { _lookup[i] = -1; } }
public RunCmd(ExecutableModel exe) { this.Exe = exe; Exe.Path = Exe.Path.Replace("%user%", Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)); Exe.Path = Exe.Path.Replace("%windir%", Environment.GetFolderPath(Environment.SpecialFolder.Windows)); Exe.Path = Exe.Path.Replace("%Dropbox%", Environment.GetEnvironmentVariable("Dropbox", EnvironmentVariableTarget.User)); }
private void doneBtn_Click(object sender, EventArgs e) { // Save settings. SettingsModal data = new SettingsModal(); foreach (ListViewItem item in ScriptCommandList.Items) { CommandModel cmd = new CommandModel(); cmd.Name = item.SubItems[0].Text; cmd.Help = item.SubItems[1].Text; cmd.SourceCode = item.SubItems[2].Text; data.Commands.Add(cmd); } foreach (ListViewItem item in ExecutablesList.Items) { ExecutableModel exe = new ExecutableModel(); exe.Name = item.SubItems[0].Text; exe.Path = item.SubItems[1].Text; exe.Arguments = item.SubItems[2].Text; data.Executables.Add(exe); } SettingsManager.SaveSettings(data); DialogResult = DialogResult.OK; Close(); }
public ActionResult Executable(ExecutableModel model) { if (ModelState.IsValid) { service.SaveExecutable(model); return(RedirectToAction("Index")); } return(View(model)); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="model">The model the successors are computed for.</param> /// <param name="capacity">The maximum number of successors that can be cached.</param> /// <param name="formulas">The formulas that should be checked for all successor states.</param> public LtmcTransitionSetBuilder(ExecutableModel <TExecutableModel> model, long capacity, params Func <bool>[] formulas) { Requires.NotNull(model, nameof(model)); Requires.NotNull(formulas, nameof(formulas)); Requires.That(formulas.Length < 32, "At most 32 formulas are supported."); Requires.That(capacity <= (1 << 30), nameof(capacity), $"Maximum supported capacity is {1 << 30}."); _stateVectorSize = model.StateVectorSize; _formulas = formulas; _capacity = capacity; _transitionBuffer.Resize(capacity * sizeof(LtmcTransition), zeroMemory: false); _transitions = (LtmcTransition *)_transitionBuffer.Pointer; _targetStateBuffer.Resize(capacity * model.StateVectorSize, zeroMemory: true); _targetStateMemory = _targetStateBuffer.Pointer; }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="model">The model the successors are computed for.</param> /// <param name="capacity">The maximum number of successors that can be cached.</param> /// <param name="formulas">The formulas that should be checked for all successor states.</param> public LtmdpCachedLabeledStates(ExecutableModel <TExecutableModel> model, long capacity, LtmdpStepGraph ltmdpStepGraph, params Func <bool>[] formulas) { Requires.NotNull(model, nameof(model)); Requires.NotNull(formulas, nameof(formulas)); Requires.That(formulas.Length < 32, "At most 32 formulas are supported."); Requires.That(capacity <= (1 << 30), nameof(capacity), $"Maximum supported capacity is {1 << 30}."); _stateVectorSize = model.StateVectorSize; _formulas = formulas; _capacity = capacity; LtmdpStepGraph = ltmdpStepGraph; _transitionsWithContinuationIdBuffer.Resize(capacity * sizeof(LtmdpTransition), zeroMemory: false); _transitionsWithContinuationIdMemory = (LtmdpTransition *)_transitionsWithContinuationIdBuffer.Pointer; _targetStateBuffer.Resize(capacity * model.StateVectorSize, zeroMemory: true); _targetStateMemory = _targetStateBuffer.Pointer; }
/// <summary> /// Adds a transition to the <paramref name="model" />'s current state. /// </summary> /// <param name="model">The model the transition should be added for.</param> /// <param name="probability">The probability of the transition.</param> public void Add(ExecutableModel <TExecutableModel> model, double probability) { _totalCount++; // 1. Notify all fault activations, so that the correct activation is set in the run time model // (Needed to persist persistent faults) model.NotifyFaultActivations(); // 2. Serialize the model's computed state; that is the successor state of the transition's source state // _including_ any changes resulting from notifications of fault activations var temporaryState = _temporalStateStorage.ZeroedSpecialAddress1(); model.Serialize(temporaryState); // 3. Store the transition var activatedFaults = FaultSet.FromActivatedFaults(model.NondeterministicFaults); AddTransition(temporaryState, new StateFormulaSet(_formulas), activatedFaults, probability); }
/// <summary> /// Adds a transition to the <paramref name="model" />'s current state. /// </summary> /// <param name="model">The model the transition should be added for.</param> public void Add(ExecutableModel <TExecutableModel> model) { if (_count >= _capacity) { throw new OutOfMemoryException("Unable to store an additional transition. Try increasing the successor state capacity."); } ++_computedCount; // 1. Serialize the model's computed state; that is the successor state of the transition's source state // modulo any changes resulting from notifications of fault activations var successorState = _targetStateMemory + _stateVectorSize * _count; var activatedFaults = FaultSet.FromActivatedFaults(model.NondeterministicFaults); model.Serialize(successorState); // 2. Make sure the transition we're about to add is activation-minimal if (!Add(successorState, activatedFaults)) { return; } // 3. Execute fault activation notifications and serialize the updated state if necessary if (model.NotifyFaultActivations()) { model.Serialize(successorState); } // 4. Store the transition _transitions[_count] = new CandidateTransition { TargetStatePointer = successorState, Formulas = new StateFormulaSet(_formulas), ActivatedFaults = activatedFaults, Flags = TransitionFlags.IsValidFlag, }; ++_count; }
public void SaveExecutable(ExecutableModel model) { var json = JsonConvert.SerializeObject(model); File.WriteAllText(configurationService.GetExecutableFilePath(model.Name), json); }