plugins/net.mograsim.logic.model.am2900/src/net/mograsim/logic/model/am2900/machine/Am2900Machine.java

   1 package net.mograsim.logic.model.am2900.machine;
   2
   3 import java.util.HashSet;
   4 import java.util.List;
   5 import java.util.Set;
   6 import java.util.function.Consumer;
   7
   8 import net.mograsim.logic.core.components.CoreClock;
   9 import net.mograsim.logic.core.timeline.Timeline;
  10 import net.mograsim.logic.core.types.Bit;
  11 import net.mograsim.logic.core.types.BitVector;
  12 import net.mograsim.logic.model.am2900.machine.registers.Am2900Register;
  13 import net.mograsim.logic.model.am2900.machine.registers.muInstrRegister;
  14 import net.mograsim.logic.model.model.LogicModel;
  15 import net.mograsim.logic.model.model.LogicModelModifiable;
  16 import net.mograsim.logic.model.model.components.ModelComponent;
  17 import net.mograsim.logic.model.model.components.atomic.ModelClock;
  18 import net.mograsim.logic.model.modeladapter.CoreModelParameters;
  19 import net.mograsim.logic.model.modeladapter.CoreModelParameters.CoreModelParametersBuilder;
  20 import net.mograsim.logic.model.modeladapter.LogicCoreAdapter;
  21 import net.mograsim.logic.model.serializing.IndirectModelComponentCreator;
  22 import net.mograsim.machine.AssignableMainMemory;
  23 import net.mograsim.machine.Machine;
  24 import net.mograsim.machine.MachineDefinition;
  25 import net.mograsim.machine.StandardMainMemory;
  26 import net.mograsim.machine.mi.AssignableMPROM;
  27 import net.mograsim.machine.mi.AssignableMicroInstructionMemory;
  28 import net.mograsim.machine.mi.MicroInstruction;
  29 import net.mograsim.machine.mi.MicroInstructionDefinition;
  30 import net.mograsim.machine.mi.StandardMPROM;
  31 import net.mograsim.machine.mi.StandardMicroInstructionMemory;
  32 import net.mograsim.machine.mi.parameters.MicroInstructionParameter;
  33 import net.mograsim.machine.mi.parameters.ParameterClassification;
  34 import net.mograsim.machine.registers.Register;
  35 import net.mograsim.machine.registers.RegisterGroup;
  36
  37 public class Am2900Machine implements Machine
  38 {
  39         private AbstractAm2900MachineDefinition machineDefinition;
  40         private LogicModelModifiable logicModel;
  41         private ModelComponent am2900;
  42         private Timeline timeline;
  43         private AssignableMainMemory mainMemory;
  44         private AssignableMicroInstructionMemory instMemory;
  45         private AssignableMPROM mprom;
  46         private CoreClock clock;
  47         private long activeInstructionAddress;
  48
  49         private final Set<ActiveMicroInstructionChangedListener> amicListeners;
  50
  51         public Am2900Machine(LogicModelModifiable model, AbstractAm2900MachineDefinition am2900MachineDefinition)
  52         {
  53                 this.machineDefinition = am2900MachineDefinition;
  54                 this.logicModel = model;
  55                 this.am2900 = IndirectModelComponentCreator.createComponent(logicModel,
  56                                 "resloader:Am2900Loader:jsonres:net/mograsim/logic/model/am2900/components/Am2900.json", "Am2900");
  57                 this.amicListeners = new HashSet<>();
  58
  59                 CoreModelParametersBuilder paramsBuilder = new CoreModelParametersBuilder();
  60                 paramsBuilder.gateProcessTime = 50;
  61                 paramsBuilder.hardcodedComponentProcessTime = paramsBuilder.gateProcessTime * 5;
  62                 paramsBuilder.wireTravelTime = 10;
  63                 CoreModelParameters params = paramsBuilder.build();
  64
  65                 mainMemory = new AssignableMainMemory(new StandardMainMemory(am2900MachineDefinition.getMainMemoryDefinition()));
  66                 instMemory = new AssignableMicroInstructionMemory(
  67                                 new StandardMicroInstructionMemory(am2900MachineDefinition.getMicroInstructionMemoryDefinition()));
  68                 mprom = new AssignableMPROM(new StandardMPROM(am2900MachineDefinition.getMPROMDefinition()));
  69                 timeline = LogicCoreAdapter.convert(logicModel, params);
  70                 am2900.setHighLevelState("ram.memory_binding", mainMemory);
  71                 am2900.setHighLevelState("mpm.memory_binding", instMemory);
  72                 am2900.setHighLevelState("mprom.memory_binding", mprom);
  73                 clock = logicModel.getComponentBySubmodelPath("Am2900.Clock#0", ModelClock.class).getClock();
  74                 clock.registerObserver(c ->
  75                 {
  76                         if (clock.isOn())
  77                         {
  78                                 long oldAddress = activeInstructionAddress;
  79                                 activeInstructionAddress = getCurrentMicroInstructionAddress();
  80                                 notifyActiveMicroInstructionChangedListeners(oldAddress, activeInstructionAddress);
  81                         }
  82                 });
  83         }
  84
  85         @Override
  86         public MachineDefinition getDefinition()
  87         {
  88                 return machineDefinition;
  89         }
  90
  91         @Override
  92         public void reset()
  93         {
  94                 MicroInstructionDefinition muiDef = getDefinition().getMicroInstructionMemoryDefinition().getMicroInstructionDefinition();
  95                 ParameterClassification[] paramClassifications = muiDef.getParameterClassifications();
  96                 MicroInstructionParameter[] defaultParams = muiDef.createDefaultInstruction().getParameters();
  97                 defaultParams[19] = paramClassifications[19].parse("JZ");
  98                 MicroInstruction jzMI = MicroInstruction.create(defaultParams);
  99                 am2900.setHighLevelState("muir_2.q", jzMI.toBitVector());
 100                 Bit regsValue = machineDefinition.expert ? Bit.U : Bit.ZERO;
 101                 setRegistersTo(machineDefinition.getUnsortedRegisters(), regsValue);
 102                 setRegisterGroupTo(machineDefinition.getRegisterGroups(), regsValue);
 103                 // TODO reset latches?
 104         }
 105
 106         private void setRegistersTo(List<Register> registers, Bit value)
 107         {
 108                 for (Register r : registers)
 109                         if (r != muInstrRegister.instance)// don't reset; sometimes causes a glitch
 110                                 setRegister(r, BitVector.of(value, r.getWidth()));
 111         }
 112
 113         private void setRegisterGroupTo(List<RegisterGroup> registerGroups, Bit value)
 114         {
 115                 for (RegisterGroup rg : registerGroups)
 116                 {
 117                         setRegistersTo(rg.getRegisters(), value);
 118                         setRegisterGroupTo(rg.getSubGroups(), value);
 119                 }
 120         }
 121
 122         @Override
 123         public LogicModel getModel()
 124         {
 125                 return logicModel;
 126         }
 127
 128         public ModelComponent getAm2900()
 129         {
 130                 return am2900;
 131         }
 132
 133         @Override
 134         public Timeline getTimeline()
 135         {
 136                 return timeline;
 137         }
 138
 139         @Override
 140         public CoreClock getClock()
 141         {
 142                 return clock;
 143         }
 144
 145         @Override
 146         public BitVector getRegister(Register r)
 147         {
 148                 return castAm2900Register(r).read(am2900);
 149         }
 150
 151         @Override
 152         public void setRegister(Register r, BitVector value)
 153         {
 154                 castAm2900Register(r).write(am2900, value);
 155         }
 156
 157         @Override
 158         public void addRegisterListener(Register r, Consumer<BitVector> listener)
 159         {
 160                 castAm2900Register(r).addListener(am2900, listener);
 161         }
 162
 163         @Override
 164         public void removeRegisterListener(Register r, Consumer<BitVector> listener)
 165         {
 166                 castAm2900Register(r).removeListener(am2900, listener);
 167         }
 168
 169         private static Am2900Register castAm2900Register(Register r)
 170         {
 171                 if (r instanceof Am2900Register)
 172                         return (Am2900Register) r;
 173                 throw new IllegalArgumentException("Not a register of an Am2900Machine: " + r);
 174         }
 175
 176         @Override
 177         public AssignableMainMemory getMainMemory()
 178         {
 179                 return mainMemory;
 180         }
 181
 182         @Override
 183         public AssignableMicroInstructionMemory getMicroInstructionMemory()
 184         {
 185                 return instMemory;
 186         }
 187
 188         @Override
 189         public AssignableMPROM getMPROM()
 190         {
 191                 return mprom;
 192         }
 193
 194         @Override
 195         public long getActiveMicroInstructionAddress()
 196         {
 197                 return activeInstructionAddress;
 198         }
 199
 200         private long getCurrentMicroInstructionAddress()
 201         {
 202                 BitVector vector = (BitVector) am2900.getHighLevelState("mpm_address");
 203                 return vector.isBinary() ? vector.getUnsignedValueLong() : -1;
 204         }
 205
 206         @Override
 207         public void addActiveMicroInstructionChangedListener(ActiveMicroInstructionChangedListener listener)
 208         {
 209                 amicListeners.add(listener);
 210         }
 211
 212         @Override
 213         public void removeActiveMicroInstructionChangedListener(ActiveMicroInstructionChangedListener listener)
 214         {
 215                 amicListeners.remove(listener);
 216         }
 217
 218         private void notifyActiveMicroInstructionChangedListeners(long oldAddress, long newAddress)
 219         {
 220                 amicListeners.forEach(l -> l.instructionChanged(oldAddress, newAddress));
 221         }
 222 }