public void InitializeMicroASM(string[] asmCodeLines, string asmFileName)
{
Clear();
if (asmFileName == null)
{
AssemblyLogger = new AssemblyLogger("Assembly");
}
else
{
AssemblyLogger = new AssemblyLogger(asmFileName);
}
Lexer lexer = new Lexer(asmCodeLines);
Parser parser = new Parser(lexer);
Compiler compiler = new Compiler(parser, AssemblyLogger);
compiler.Compile();
OBJFileLines = compiler.GetOutput();
//Micro simulator setup
VirtualMemory = new VirtualMemory(OBJFileLines);
// state the last port for the micro
IoManager = new IOManager(VirtualMemory.VirtualMemorySize - 1);
Micro = new MicroSimulator(VirtualMemory, IoManager);
}
public Interruptor(Processor processor, VirtualMemory virtualMemory, FileManager fileManager, RealMemory realMemory)
{
Processor = processor;
VirtualMemory = virtualMemory;
FileManager = fileManager;
RealMemory = realMemory;
}
private bool FileWriteChosenInterrupt()
{
int[] xy = GetCurrentCommandLastTwoArguments();
int R1 = Processor.GetRegisterValue("R1").HexToInt();
int R2 = Processor.GetRegisterValue("R2").HexToInt();
char[][] blockToFile = new char[R2][];
bool first = true;
for (int i = 0, block = 0; i < R2; block++)
{
for (int ii = 0; ii < Utility.BLOCK_SIZE || i < R2; ii++, i++)
{
if (first)
{
ii = xy[1]; first = false;
}
int blockAddress = VirtualMemory.GetPager().GetCellRealAddress(((xy[0]) + block) * Utility.BLOCK_SIZE);
blockToFile[i] = RealMemory.GetUserMemoryValue(blockAddress + ii);
}
}
bool result = FileManager.WriteFile(R1, blockToFile);
if (!result)
{
return(false);
}
ResetSIRegister();
return(true);
}
public void MicroSimulatorTests_ProfTest3_Success()
{
string[] asmLines = FileManager.Instance.ToReadFile(test3);
Lexer lexer = new Lexer(asmLines);
Parser parser = new Parser(lexer);
Compiler assembler = new Compiler(parser);
assembler.Compile();
string[] objData = assembler.GetOutput();
VirtualMemory vm = new VirtualMemory(objData);
MicroSimulator micro = new MicroSimulator(vm);
int i = 0;
while (i < 1000)
{
micro.NextInstruction();
i++;
}
Console.WriteLine(micro.MicroRegisters);
Console.WriteLine(vm.ToString());
Assert.AreEqual("Registers[0,0,0,0,0,12,15,125]", micro.MicroRegisters.ToString());
}
private bool FileReadChosenInterrupt()
{
int[] xy = GetCurrentCommandLastTwoArguments();
int R1 = Processor.GetRegisterValue("R1").HexToInt();
int R2 = Processor.GetRegisterValue("R2").HexToInt();
char[][] blockFromFile = FileManager.ReadFile(R1, R2);
if (blockFromFile == null)
{
return(false);
}
bool first = true;
for (int i = 0, block = 0; i < R2; block++)
{
for (int ii = 0; ii < Utility.BLOCK_SIZE || i < R2; ii++, i++)
{
if (first)
{
ii = xy[1]; first = false;
}
int blockAddress = VirtualMemory.GetPager().GetCellRealAddress(((xy[0]) + block) * Utility.BLOCK_SIZE);
RealMemory.SetUserMemoryValue(blockAddress + ii, blockFromFile[i]);
}
}
ResetSIRegister();
return(true);
}
static void PrintElem(VirtualMemory vm)
{
var pageNumber = AskInt(new[] { $"Введите номер страницы (0 - {vm.PageNumber - 1})" }, 0, vm.PageNumber - 1);
var elemNumber = AskInt(new[] { $"Введите номер элемента (0 - {vm.PageCapacity - 1})" }, 0, vm.PageCapacity - 1);
Message(new [] { $"Page #{pageNumber} Elem #{elemNumber}: {vm[pageNumber, elemNumber]}" });
}
static void Check(VirtualMemory vm)
{
var pageNumber = AskInt(new[] { $"Введите номер страницы (0 - {vm.PageNumber - 1})" }, 0, vm.PageNumber - 1);
var elemNumber = AskInt(new[] { $"Введите номер элемента (0 - {vm.PageCapacity - 1})" }, 0, vm.PageCapacity - 1);
Message(new[] { $"Page #{pageNumber} Elem #{elemNumber}: { (vm.IsEmpty(pageNumber, elemNumber) ? "EMPTY" : "NOT EMPTY") }" });
}
/// <summary>
/// Executes the algorithm.
/// </summary>
/// <param name="virtualMemory">Virtual memory to use</param>
/// <param name="pageSequence">Page sequence to use</param>
/// <returns>Amount of misses</returns>
public int Execute(VirtualMemory virtualMemory, string[] pageSequence)
{
var missCount = 0;
var i = 0;
var hashtable = new Hashtable();
foreach (var page in pageSequence)
{
Console.WriteLine("==========================================================");
Console.WriteLine($"LRU Solicitud del procesador para ingresar página {page}");
Console.WriteLine($"Memoria disponible: {virtualMemory.GetCurrentFreeCapacity()} [KB]");
// While the virtual memory is not full
if (i < virtualMemory.PageCount)
{
// If the page is not added, add it
if (!hashtable.ContainsKey(page))
{
hashtable.Add(page, 1);
Console.WriteLine($"Página {page} agregada a la hashtable");
}
else // If the page exists, increment its counter
{
hashtable[page] = (int)hashtable[page] + 1;
Console.WriteLine($"Página {page} ya existente en la hashtable. Cantidad: {hashtable[page]}");
}
virtualMemory[i++] = page;
Console.WriteLine($"Página {page} agregada a la memoria virtual en la posición {i}");
continue;
}
// While the virtual memory is full and we have a miss
if (virtualMemory.FindPage(page) == -1)
{
Console.WriteLine("(i) Miss (i)");
var pageToReplace = "MinKey";
var currentMin = int.MaxValue;
foreach (var k in hashtable.Keys)
{
if ((int)hashtable[k] < currentMin)
{
pageToReplace = k as string;
currentMin = (int)hashtable[k];
}
}
Console.WriteLine($"Página a reemplazar: {pageToReplace}");
var indexToReplace = virtualMemory.FindPage(pageToReplace);
Console.WriteLine($"Posición a reemplazar dentro de la memoria virtual: {indexToReplace}");
virtualMemory[indexToReplace] = page;
hashtable.Remove(pageToReplace);
Console.WriteLine($"Página {pageToReplace} eliminada de la hashtable");
hashtable.Add(page, 1);
Console.WriteLine($"Página {page} agregada a la hashtable");
missCount++;
}
else
{
Console.WriteLine("(i) Hit (i)");
}
}
return(missCount);
}
public Processor(RealMemory realMemory, ChannelTool channelTool, VirtualMemory virtualMemory = null, Pager pager = null)
{
RealMemory = realMemory;
VirtualMemory = virtualMemory;
ChannelTool = channelTool;
Pager = pager;
FileManager = new FileManager(RealMemory, this);
CommandInterpretator = new CommandInterpretator(this, virtualMemory);
Interruptor = new Interruptor(this, virtualMemory, FileManager, RealMemory);
// STOPS PROGRAM AFTER MAX STEP COUNT
UseMaxStep = true;
// CURRENT STEP
CurrentStep = 0;
registers = new Dictionary <string, Register>
{
{ "R1", new Register(value: 0) }, // Word length general register
{ "R2", new Register(value: 0) }, // Word length general register
{ "IC", new HexRegister(2) }, // Current command adress in memory register
{ "PTR", new HexRegister(4) }, // Page table adress register
{ "SF", new StatusFlagRegister() }, // Aritmetic operation logic values
{ "MODE", new ChoiceRegister('N', 'S') }, // Processor mode "N" - user, "S" - supervisor
{ "PI", new ChoiceRegister(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) }, // Program interuptor
{ "SI", new ChoiceRegister(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) }, // Supervisor interuptor
{ "TI", new HexRegister(Utility.TIMER_VALUE, 1) } // Timer interuptor
};
}
public bool Step()
{
char[] stepCommand = VirtualMemory.GetValue(GetICRegisterValue());
char[] nextCommand = VirtualMemory.GetValue(GetICRegisterValue() + 1);
string stringCommand = new string(stepCommand);
string stringNext = new string(nextCommand);
Console.WriteLine("STEP: " + stringCommand + " (NEXT: " + stringNext + ")");
bool commandResult = CommandInterpretator.ParseCommand(stepCommand);
if (Test())
{
if (!Interrupt())
{
FileManager.CloseAll(); return(false);
}
}
if (ChangedIC)
{
ChangedIC = false;
}
else
{
IncICRegisterValue(1);
}
if (UseMaxStep && CurrentStep++ >= Utility.MAX_STEPS)
{
return(StopProgram());
}
return(commandResult);
}
public void SetVirtualMemory(VirtualMemory virtualMemory, Pager pager)
{
VirtualMemory = virtualMemory;
Pager = pager;
SetPTRRegisterValue(pager.GetPTR());
CommandInterpretator.SetVirtualMemory(virtualMemory);
Interruptor.SetVirtualMemory(virtualMemory);
}
private bool OutputBlockInterrupt()
{
int x = GetCurrentCommandLastArgument();
Processor.UseChannelTool(VirtualMemory.GetPager().GetCellRealAddress(x * Utility.BLOCK_SIZE), 0, 1, 4);
ResetSIRegister();
return(true);
}
public void SetVirtualHarware(Error error)
{
memory = new VirtualMemory(memoryCapacity);
register = new Register();
cpu = new VirtualCPU();
cpu.SetVirtualCPU(memory, register, error);
this.error = error;
}
public void VirtualMemoryTest_ReadStringLines_BiggerThan16Bit_Fail()
{
string[] lines = FileManager.Instance.ToReadFile(machineCodeFileInvalid);
Assert.IsNotNull(lines);
VirtualMemory vm = new VirtualMemory(lines);
}
public void ASCIIDisplayTests_TestPorts_Write()
{
VirtualMemory vm = new VirtualMemory(new string[] {
"0000",
"0000",
"0000",
"0000",
"0000",
"0000",
"0000",
"0000"
});
IOManager manager = new IOManager(100);
MicroSimulator micro = new MicroSimulator(vm, manager);
Console.WriteLine("Starting State:");
Console.Write(vm);
Console.WriteLine(manager);
Console.WriteLine(micro);
ushort start_port = 5;
ASCII_Display display = new ASCII_Display(start_port, true);
manager.AddIODevice(start_port, display);
Console.WriteLine("\nAfter adding ASCII Display:");
Console.WriteLine(manager);
Console.WriteLine($"\nIO Device: {display}");
Assert.AreEqual("00", display.ReadFromPort(5));
//Write To Valid port range
Assert.IsTrue(display.WriteInPort(5, "48"));
Assert.IsTrue(display.WriteInPort(6, "6F"));
Assert.IsTrue(display.WriteInPort(7, "6C"));
Assert.IsTrue(display.WriteInPort(8, "61"));
Console.WriteLine(display);
//Writing into invalid Ports
//Positive before valid range
Assert.AreEqual(display.WriteInPort(4, "X"), false);
//Positive after valid range
Assert.AreEqual(display.WriteInPort(13, "X"), false);
//Maximum Port Number
Assert.AreEqual(display.WriteInPort(short.MaxValue, "X"), false);
//Negative Port Number
Assert.AreEqual(display.WriteInPort(short.MinValue, "X"), false);
}
static void Menu(VirtualMemory vm)
{
int command;
while (true)
{
command = AskInt(_menu, 0, 6);
_menuActions[command].Invoke(vm);
}
}
public override void Copy(VirtualMemory source)
{
base.Copy(source);
Height = ((VirtualFrame)source).Height;
Width = ((VirtualFrame)source).Width;
xOffset = ((VirtualFrame)source).xOffset;
yOffset = ((VirtualFrame)source).yOffset;
BytesPerPixel = ((VirtualFrame)source).BytesPerPixel;
TransparentColor = ((VirtualFrame)source).TransparentColor;
}
public void VirtualMemoryTest_ReadStringLines_InvalidHexAddress()
{
string[] lines = FileManager.Instance.ToReadFile(machineCodeFile);
Assert.IsNotNull(lines);
VirtualMemory vm = new VirtualMemory(lines);
vm.GetContentsInHex("1194");
}
public void VirtualMemoryTest_InvalidData_InvalidHexAddress()
{
string[] lines = FileManager.Instance.ToReadFile(machineCodeFile);
Assert.IsNotNull(lines);
VirtualMemory vm = new VirtualMemory(lines);
vm.SetContentInMemory(45, "1194");
}
public void ResolvesIndexedIndirectAddress()
{
var memory = new VirtualMemory();
var state = Mos6502State.PowerUp.With(pc: 0x01, x: 0x02);
memory.Attach(0x0000, new byte[] { 0xAB, 0xAB, 0x10 });
memory.Attach(0x0010, new byte[] { 0xAB, 0xAB, 0xEF, 0xBE });
var(address, _) = Mos6502Executor.ResolveAddress(Mos6502AddressingMode.IndexedIndirect, in state, memory);
Assert.Equal(0xBEEF, address);
}
public void LoadNextPage()
{
var replacing = _pagesToLoad.Current;
if (replacing == null)
{
throw new NullReferenceException("no more pages to load");
}
VirtualMemory.Accept(replacing);
PhysicalMemory.Accept(replacing);
_pagesToLoad.MoveNext();
}
public void ResolvesIndirectIndexedAddress()
{
var memory = new VirtualMemory();
var state = Mos6502State.PowerUp.With(pc: 0x01, y: 0x02);
memory.Attach(0x0000, new byte[] { 0xAB, 0xAB, 0x12 });
memory.Attach(0x0010, new byte[] { 0xAB, 0xAB, 0x10, 0x10 });
var(address, crossesBoundary) = Mos6502Executor.ResolveAddress(Mos6502AddressingMode.IndirectIndexed, in state, memory);
Assert.Equal(0x1012, address);
Assert.False(crossesBoundary);
}
public void IndicatesIfAPageBoundaryIsCrossedByIndirectIndexing()
{
var memory = new VirtualMemory();
var state = Mos6502State.PowerUp.With(pc: 0x01, y: 0x01);
memory.Attach(0x0000, new byte[] { 0xAB, 0xAB, 0x12 });
memory.Attach(0x0010, new byte[] { 0xAB, 0xAB, 0xFF, 0x1F });
var(address, crossesBoundary) = Mos6502Executor.ResolveAddress(Mos6502AddressingMode.IndirectIndexed, in state, memory);
Assert.Equal(0x2000, address);
Assert.True(crossesBoundary);
}
public void ASCIIDisplayTests_ReadFromMicro_Success()
{
VirtualMemory vm = new VirtualMemory(new string[] {
"0000",
"0000",
"0000",
"0000",
"0000",
"0000",
"0000",
"0000"
});
IOManager manager = new IOManager(100);
MicroSimulator micro = new MicroSimulator(vm, manager);
Console.WriteLine("Starting State:");
Console.Write(vm);
Console.WriteLine(manager);
Console.WriteLine(micro);
ASCII_Display display = new ASCII_Display(5, true);
manager.AddIODevice(5, display);
Console.WriteLine("\nAfter adding ASCII Display:");
Console.WriteLine(manager);
Console.WriteLine($"\nIO Device: {display}");
Assert.AreEqual("00", display.ReadFromPort(5));
display.WriteInPort(5, "48");
display.WriteInPort(6, "6F");
display.WriteInPort(7, "6C");
display.WriteInPort(8, "61");
Console.WriteLine(display);
string h = micro.ReadFromMemory(5);
string o = micro.ReadFromMemory(6);
string l = micro.ReadFromMemory(7);
string a = micro.ReadFromMemory(8);
Assert.AreEqual("48", h);
Assert.AreEqual("6F", o);
Assert.AreEqual("6C", l);
Assert.AreEqual("61", a);
Console.WriteLine($"\nContent read in Hex: {h} {o} {l} {a}");
}
private bool FileDeleteInterrupt()
{
int x = GetCurrentCommandSecondLastArgument();
char[][] fileNameBlock = VirtualMemory.GetBlockValues(x * Utility.BLOCK_SIZE);
if (!FileManager.DeleteFile(fileNameBlock))
{
return(false);
}
ResetSIRegister();
return(false);
}
private string GetPrettyInstruction(IMCInstruction instruction)
{
if (instruction == null)
{
return("");
}
string addressHex = UnitConverter.IntToHex(instruction.InstructionAddressDecimal, defaultWidth: 3);
string contentHex = VirtualMemory.GetContentsInHex(instruction.InstructionAddressDecimal) +
VirtualMemory.GetContentsInHex(instruction.InstructionAddressDecimal + 1);
return($"{addressHex}: {contentHex}: {instruction.ToString()}");
}
public void InitializeMicroOBJ(string[] objFileLines)
{
Clear();
OBJFileLines = objFileLines;
//Micro simulator setup
VirtualMemory = new VirtualMemory(OBJFileLines);
// state the last port for the micro
IoManager = new IOManager(VirtualMemory.VirtualMemorySize - 1);
Micro = new MicroSimulator(VirtualMemory, IoManager);
}
public void MCLoaderTests_ExecuteOneInstruction_Success()
{
string expected = "MCInstructionF3[InstructionAddressDecimal: (decimal)'0', opcode:'21', AddressParamHex:'06']";
VirtualMemory vm = new VirtualMemory(new string[] { "A8 06" });
MCLoader l = new MCLoader(vm, new MicroSimulator(vm));
IMCInstruction i = l.NextInstruction();
Console.WriteLine(i);
Assert.AreEqual(expected, i.ToString());
}
private bool FileReadBlockInterrupt()
{
int[] xy = GetCurrentCommandLastTwoArguments();
char[][] blockFromFile = FileManager.ReadFile(xy[0]);
if (blockFromFile == null)
{
return(false);
}
VirtualMemory.SetBlockValues(xy[1] * Utility.BLOCK_SIZE, blockFromFile);
ResetSIRegister();
return(true);
}
private bool FileWriteBlockInterrupt()
{
int[] xy = GetCurrentCommandLastTwoArguments();
char[][] blockToFile = VirtualMemory.GetBlockValues(xy[1] * Utility.BLOCK_SIZE);
bool result = FileManager.WriteFile(xy[0], blockToFile);
if (!result)
{
return(false);
}
ResetSIRegister();
return(true);
}
