public Processor() { stateLock = new object(); successFileCountLock = new object(); failureFileCountLock = new object(); totalFileCountLock = new object(); validFileCountLock = new object(); totalSampleCountLock = new object(); sharedSampleCountLock = new object(); workerSampleCountLock = new object(); updateIntervalLock = new object(); tasksLock = new object(); finishedWorkerCountLock = new object(); inputFilenamesLock = new object(); outputDirectoryLock = new object(); priorityLock = new object(); conversionUpdateTimer = new System.Timers.Timer(); conversionUpdateTimer.Enabled = false; conversionUpdateTimer.Elapsed += conversionUpdateTimer_Elapsed; conversionUpdateTimer.AutoReset = true; workerCount = Environment.ProcessorCount; state = ProcessorState.Idle; updateInterval = 1000; workerSampleCount = new ulong[workerCount]; workers = new Thread[workerCount]; tasks = new Stack<ProcessorTask>(); inputFilenames = null; outputDirectory = null; priority = ProcessPriorityClass.Normal; }
/// <summary> /// Provides the notification on the change of process state to interested parties. /// </summary> public virtual void ChangeProcessorState(ProcessorState newProcessorState) { if (newProcessorState == currentProcessorState) return; OnNotifyProcessorStateChanging(newProcessorState); currentProcessorState = newProcessorState; if (ProcessResult != null) ProcessResult.FinalProcessorState = newProcessorState; }
public ProcessorState Clone(Instruction instruction, Instruction last = null) { var state = new ProcessorState(null, new VariableInfo[Locals.Length], Args.ToArray(), instruction, last, Delegates); var addressMap = new Dictionary<Address, Address>(); var buffer = new List<Address>(); foreach (var address in Stack) { buffer.Add(address.Clone(addressMap)); } state.Stack = new Stack<Address>(Enumerable.Reverse(buffer)); for (int i = 0; i < Locals.Length; i++) { state.Locals[i] = new VariableInfo(Locals[i].Type); state.Locals[i].Address = Locals[i].Address.Clone(addressMap); } return state; }
public void Process(ProcessItemHandler handler) { switch (this.State) { case ProcessorState.InProcess: throw new InvalidOperationException("Processor already in process"); case ProcessorState.Finished: throw new InvalidOperationException("Cannot start one processor twice"); } this.FState = ProcessorState.InProcess; try { this.DoProcess(handler); } finally { this.FState = ProcessorState.Finished; } }
public void Merge(Expression test, ProcessorState leftState, ProcessorState rightState) { var addressMap = new Dictionary<Tuple<Address, Address>, Address>(); for (int i = 0; i < leftState.Locals.Length; i++) { var leftLocal = leftState.Locals[i]; var rightLocal = rightState.Locals[i]; Locals[i].Address = Address.Merge(test, leftLocal.Address, rightLocal.Address, addressMap); } var buffer = new List<Address>(); while (leftState.Stack.Count > 0 || rightState.Stack.Count > 0) { var rightExpression = rightState.Stack.Pop(); var leftExpression = leftState.Stack.Pop(); buffer.Add(Address.Merge(test, leftExpression, rightExpression, addressMap)); } Stack.Clear(); foreach (var address in Enumerable.Reverse(buffer)) { Stack.Push(address); } }
static Expression[] GetArguments(ProcessorState state, MethodBase m) { var parameterInfos = m.GetParameters(); var mArgs = new Expression[parameterInfos.Length]; for (var i = parameterInfos.Length - 1; i >= 0; i--) { mArgs[i] = state.Stack.Pop(); } return mArgs; }
static void Call(ProcessorState state, MethodInfo m) { var mArgs = GetArguments(state, m); var instance = m.IsStatic ? new Address() : state.Stack.Pop(); var result = BuildMethodCallExpression(m, instance, mArgs); if (result.Type != typeof(void)) state.Stack.Push(result); }
static void LdC(ProcessorState state, double i) { state.Stack.Push(Expression.Constant(i)); }
static void StElem(ProcessorState state) { var value = state.Stack.Pop(); var index = state.Stack.Pop(); var array = state.Stack.Pop(); var newArray = array.Expression as NewArrayExpression; if (newArray != null) { var expressions = CreateArrayInitExpressions(newArray, value, index); var newArrayInit = Expression.NewArrayInit(array.Type.GetElementType(), expressions); array.Expression = newArrayInit; } else { throw new NotImplementedException(); } }
/// <summary> /// Palaiž processora izpildītāju un uzstāda processora izpildītāja statusu uz <see cref="ProcessorState.Running"/>. /// </summary> public void Start() { lock (this) { if (this.IsRunning) { return; } _state = ProcessorState.Running; } // multiple thread instances cannot be created if (_thread == null || _thread.ThreadState == System.Threading.ThreadState.Stopped) { _thread = new Thread(new ThreadStart(Run)); _thread.Name = _processor.Name; } // start thread if it's not running yet if (_thread.ThreadState != System.Threading.ThreadState.Running) { _thread.Start(); } }
private string Write44_ProcessorState(ProcessorState v) { switch (v) { case ProcessorState.Initializing: return "Initializing"; case ProcessorState.InProcess: return "InProcess"; case ProcessorState.Finished: return "Finished"; } long num = (long) v; throw base.CreateInvalidEnumValueException(num.ToString(CultureInfo.InvariantCulture), "Nomad.FileSystem.Archive.Common.ProcessorState"); }
static void LdArg(ProcessorState state, int index) { state.Stack.Push(state.Args[index]); }
private void SetStateAndTimer(ProcessorManager processor, ProcessorState state) { processor.stateExitTime = Time.timeSinceLevelLoad + stateTimers[state]; processor.state = state; }
public void Reset() { for (int i = 0; i < RegisterCount; _Register[i++] = 0) ; _PC = 0; _SP = 0; _EX = 0; _IA = 0; _Cycles = 0; _CycleDebt = 0; _IntEnabled = true; _IntQueue.Clear(); _state = ProcessorState.newInst; ClearMemory(); }
private void Tick() { //TODO _Cycles++; if (_state == ProcessorState.newInst) { Tick_inst = nextWord(); Tick_opcode = (ushort)(Tick_inst & (ushort)0x001fu); Tick_b = (ushort)((Tick_inst & (ushort)0x03e0u) >> 5); Tick_a = (ushort)((Tick_inst & (ushort)0xfc00u) >> 10); _state = ProcessorState.readOpA; _CycleDebt = operandCycles(Tick_a); if (_CycleDebt > 0) return; } if (_state == ProcessorState.readOpA) { Tick_opA = parseOperand(Tick_a); if (Tick_opcode == 0) // Non-basic opcodes { _state = ProcessorState.executeInst; } else { _CycleDebt = operandCycles(Tick_b); _state = ProcessorState.readOpB; } if (_CycleDebt > 0) return; } if (_state == ProcessorState.readOpB) { Tick_opB = parseOperand(Tick_b); _state = ProcessorState.executeInst; _CycleDebt = opcodeCycles(Tick_a, Tick_opcode); if (_CycleDebt > 0) return; } if (_state == ProcessorState.executeInst) { if (Tick_opcode == 0) // Non-basic opcodes { //TODO: DICTIONARY switch (Tick_b) { case 0x01: opJSR(Tick_opA); break; case 0x08: opINT(Tick_opA); break; case 0x09: opIAG(Tick_opA); break; case 0x0a: opIAS(Tick_opA); break; case 0x0b: opRFI(Tick_opA); break; case 0x0c: opIAQ(Tick_opA); break; } } else // Basic opcodes { new Operation(Actions[Tick_opcode]).Invoke(Tick_opB, Tick_opA); } _state = ProcessorState.newInst; return; } }
public void Tick() { _Cycles++; foreach (Ie16Hardware hw in _Hardware) { hw.Tick(); } if (--_CycleDebt == 0) { _CycleDebt--; return; } if (_IntEnabled && _IntQueue.Count > 0) { stackPUSH(_PC); stackPUSH(_A); _PC = _IA; _Register[_A] = _IntQueue.Dequeue(); _IntEnabled = false; } if(_state == ProcessorState.newInst) { Tick_inst = nextWord(); Tick_opcode = (ushort)(Tick_inst & (ushort)0x001fu); Tick_b = (ushort)((Tick_inst & (ushort)0x03e0u) >> 5); Tick_a = (ushort)((Tick_inst & (ushort)0xfc00u) >> 10); _state = ProcessorState.readOpA; _CycleDebt = operandCycles(Tick_a); if (_CycleDebt > 0) return; } if(_state == ProcessorState.readOpA) { Tick_opA = parseOperand(Tick_a); if (Tick_opcode == 0) // Non-basic opcodes { _state = ProcessorState.executeInst; } else { _CycleDebt = operandCycles(Tick_b); _state = ProcessorState.readOpB; } if(_CycleDebt > 0) return; } if(_state == ProcessorState.readOpB) { Tick_opB = parseOperand(Tick_b); _state = ProcessorState.executeInst; _CycleDebt = opcodeCycles(Tick_a, Tick_opcode); if(_CycleDebt > 0) return; } if(_state == ProcessorState.executeInst) { if (Tick_opcode == 0) // Non-basic opcodes { switch (Tick_b) { case 0x01: opJSR(Tick_opA); break; case 0x08: opINT(Tick_opA); break; case 0x09: opIAG(Tick_opA); break; case 0x0a: opIAS(Tick_opA); break; case 0x0b: opRFI(Tick_opA); break; case 0x0c: opIAQ(Tick_opA); break; case 0x10: opHWN(Tick_opA); break; case 0x11: opHWQ(Tick_opA); break; case 0x12: opHWI(Tick_opA); break; } } else // Basic opcodes { switch (Tick_opcode) { case 0x01: opSET(Tick_opB, Tick_opA); break; case 0x02: opADD(Tick_opB, Tick_opA); break; case 0x03: opSUB(Tick_opB, Tick_opA); break; case 0x04: opMUL(Tick_opB, Tick_opA); break; case 0x05: opMLI(Tick_opB, Tick_opA); break; case 0x06: opDIV(Tick_opB, Tick_opA); break; case 0x07: opDVI(Tick_opB, Tick_opA); break; case 0x08: opMOD(Tick_opB, Tick_opA); break; case 0x09: opMDI(Tick_opB, Tick_opA); break; case 0x0a: opAND(Tick_opB, Tick_opA); break; case 0x0b: opBOR(Tick_opB, Tick_opA); break; case 0x0c: opXOR(Tick_opB, Tick_opA); break; case 0x0d: opSHR(Tick_opB, Tick_opA); break; case 0x0e: opASR(Tick_opB, Tick_opA); break; case 0x0f: opSHL(Tick_opB, Tick_opA); break; case 0x10: opIFB(Tick_opB, Tick_opA); break; case 0x11: opIFC(Tick_opB, Tick_opA); break; case 0x12: opIFE(Tick_opB, Tick_opA); break; case 0x13: opIFN(Tick_opB, Tick_opA); break; case 0x14: opIFG(Tick_opB, Tick_opA); break; case 0x15: opIFA(Tick_opB, Tick_opA); break; case 0x16: opIFL(Tick_opB, Tick_opA); break; case 0x17: opIFU(Tick_opB, Tick_opA); break; case 0x1a: opADX(Tick_opB, Tick_opA); break; case 0x1b: opSBX(Tick_opB, Tick_opA); break; case 0x1e: opSTI(Tick_opB, Tick_opA); break; case 0x1f: opSTD(Tick_opB, Tick_opA); break; } } _state = ProcessorState.newInst; return; } }
static Expression[] GetArguments(ProcessorState state, MethodBase m) { var parameterInfos = m.GetParameters(); var mArgs = new Expression[parameterInfos.Length]; for (var i = parameterInfos.Length - 1; i >= 0; i--) { var argument = state.Stack.Pop(); var parameter = parameterInfos[i]; var parameterType = parameter.ParameterType; mArgs[i] = AdjustType(argument, parameterType); } return mArgs; }
public override Address ReadCodeAddress(int size, EndianImageReader rdr, ProcessorState state) { throw new NotImplementedException(); }
static void LdLoc(ProcessorState state, int index) { state.Stack.Push(state.Locals[index].Address); }
public override IEnumerable <RtlInstructionCluster> CreateRewriter(EndianImageReader rdr, ProcessorState state, IStorageBinder binder, IRewriterHost host) { throw new NotImplementedException(); }
static void StLoc(ProcessorState state, int index) { var info = state.Locals[index]; info.Address = AdjustType(state.Stack.Pop(), info.Type); }
public override BlockWorkitem CreateBlockWorkItem(Address addrStart, Procedure proc, ProcessorState state) { Test_State = state; Test_LastBlockWorkitem = base.CreateBlockWorkItem(addrStart, proc, state); return(Test_LastBlockWorkitem); }
/// <summary> /// Apstādina procesora izpildītāju un uzstāda processora izpildītāja statusu uz <see cref="ProjectIntegratorState.Stopping"/>. /// </summary> public void Stop() { if (this.IsRunning) { ProcessorDiagnostic.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "Stopping processor runner: {0}", _processor.Name); _state = ProcessorState.Stopping; } }
public override IEnumerable <RtlInstructionCluster> CreateRewriter(EndianImageReader rdr, ProcessorState state, IStorageBinder binder, IRewriterHost host) { return(new Rewriter(this, rdr.Clone(), state, binder, host)); }
Instruction ConditionalBranch(ProcessorState state, Func<Expression, BinaryExpression> condition) { var val1 = state.Stack.Pop(); var test = condition(val1); var left = (Instruction) state.Instruction.Operand; var right = state.Instruction.Next; Instruction common = GetJoinPoint(left, right); var rightState = state.Clone(right, common); var leftState = state.Clone(left, common); states.Push(rightState); states.Push(leftState); // Run this once the conditional branches have been processed state.RunNext = () => state.Merge(test, leftState, rightState); return common; }
/// <summary> /// Processora izpildītāis tiek apstādīnāts /// </summary> private void Stopped() { // the state was set to 'Stopping', so set it to 'Stopped' _state = ProcessorState.Stopped; _thread = null; // Ensure that any queued integrations are cleared for this project. _processingQueue.RemoveItems(_processor); ProcessorDiagnostic.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "Processor {0} is now stopped", _processor.Name); }
/// <summary> /// Raises the ProcessorStateChanging event. /// </summary> /// <param name="newProcessorState"></param> public virtual void OnNotifyProcessorStateChanging(ProcessorState newProcessorState) { if (ProcessorStateChanging != null) { ProcessorStateChanging(this, new GenericStateChangedEventArgs<ProcessorState>(currentProcessorState, newProcessorState)); } }
public override SystemService FindService(int vector, ProcessorState state) { throw new NotImplementedException(); }