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();
}
