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