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.HashMap;
   4 import java.util.HashSet;
   5 import java.util.Map;
   6 import java.util.Set;
   7 import java.util.function.Consumer;
   8
   9 import net.mograsim.logic.core.components.CoreClock;
  10 import net.mograsim.logic.core.timeline.Timeline;
  11 import net.mograsim.logic.core.types.Bit;
  12 import net.mograsim.logic.core.types.BitVector;
  13 import net.mograsim.logic.model.am2900.machine.registers.NumberedRegister;
  14 import net.mograsim.logic.model.am2900.machine.registers.QRegister;
  15 import net.mograsim.logic.model.model.LogicModel;
  16 import net.mograsim.logic.model.model.LogicModelModifiable;
  17 import net.mograsim.logic.model.model.components.ModelComponent;
  18 import net.mograsim.logic.model.model.components.atomic.ModelClock;
  19 import net.mograsim.logic.model.modeladapter.CoreModelParameters;
  20 import net.mograsim.logic.model.modeladapter.LogicCoreAdapter;
  21 import net.mograsim.logic.model.serializing.IndirectModelComponentCreator;
  22 import net.mograsim.machine.Machine;
  23 import net.mograsim.machine.MachineDefinition;
  24 import net.mograsim.machine.Register;
  25 import net.mograsim.machine.mi.AssignableMicroInstructionMemory;
  26 import net.mograsim.machine.mi.MicroInstruction;
  27 import net.mograsim.machine.mi.MicroInstructionDefinition;
  28 import net.mograsim.machine.mi.StandardMicroInstructionMemory;
  29 import net.mograsim.machine.mi.parameters.MicroInstructionParameter;
  30 import net.mograsim.machine.mi.parameters.ParameterClassification;
  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         private final Map<Register, Map<Consumer<BitVector>, Consumer<Object>>> modelListenersPerRegisterListenerPerRegister;
  47
  48         public Am2900Machine(LogicModelModifiable model, AbstractAm2900MachineDefinition am2900MachineDefinition)
  49         {
  50                 this.machineDefinition = am2900MachineDefinition;
  51                 this.logicModel = model;
  52                 this.am2900 = IndirectModelComponentCreator.createComponent(logicModel,
  53                                 "resloader:Am2900Loader:jsonres:net/mograsim/logic/model/am2900/components/Am2900.json", "Am2900");
  54                 this.amicListeners = new HashSet<>();
  55                 this.modelListenersPerRegisterListenerPerRegister = new HashMap<>();
  56
  57                 CoreModelParameters params = new CoreModelParameters();
  58                 params.gateProcessTime = 50;
  59                 params.wireTravelTime = 10;
  60                 mainMemory = new AssignableMainMemory(new WordAddressableMemory(am2900MachineDefinition.getMainMemoryDefinition()));
  61                 instMemory = new AssignableMicroInstructionMemory(
  62                                 new StandardMicroInstructionMemory(am2900MachineDefinition.getMicroInstructionMemoryDefinition()));
  63                 timeline = LogicCoreAdapter.convert(logicModel, params);
  64                 am2900.setHighLevelState("ram.memory_binding", mainMemory);
  65                 am2900.setHighLevelState("mpm.memory_binding", instMemory);
  66                 clock = logicModel.getComponentBySubmodelPath("Am2900.Clock#0", ModelClock.class).getClock();
  67                 clock.registerObserver(c ->
  68                 {
  69                         if (clock.isOn())
  70                         {
  71                                 long oldAddress = activeInstructionAddress;
  72                                 activeInstructionAddress = getCurrentMicroInstructionAddress();
  73                                 notifyActiveMicroInstructionChangedListeners(oldAddress, activeInstructionAddress);
  74                         }
  75                 });
  76         }
  77
  78         @Override
  79         public MachineDefinition getDefinition()
  80         {
  81                 return machineDefinition;
  82         }
  83
  84         @Override
  85         public void reset()
  86         {
  87                 MicroInstructionDefinition muiDef = getDefinition().getMicroInstructionMemoryDefinition().getMicroInstructionDefinition();
  88                 ParameterClassification[] paramClassifications = muiDef.getParameterClassifications();
  89                 MicroInstructionParameter[] defaultParams = muiDef.createDefaultInstruction().getParameters();
  90                 defaultParams[19] = paramClassifications[19].parse("JZ");
  91                 MicroInstruction jzMI = MicroInstruction.create(defaultParams);
  92                 am2900.setHighLevelState("muir_2.q", jzMI.toBitVector());
  93                 if (!machineDefinition.strict)
  94                 {
  95                         for (Register r : machineDefinition.getRegisters())
  96                                 setRegister(r, BitVector.of(Bit.ZERO, r.getWidth()));
  97                         // TODO reset latches?
  98                 }
  99         }
 100
 101         @Override
 102         public LogicModel getModel()
 103         {
 104                 return logicModel;
 105         }
 106
 107         public ModelComponent getAm2900()
 108         {
 109                 return am2900;
 110         }
 111
 112         @Override
 113         public Timeline getTimeline()
 114         {
 115                 return timeline;
 116         }
 117
 118         @Override
 119         public CoreClock getClock()
 120         {
 121                 return clock;
 122         }
 123
 124         // TODO too much code duplication
 125
 126         @Override
 127         public BitVector getRegister(Register r)
 128         {
 129                 String am2901CellSuffix = getAm2901CellSuffix(r);
 130                 BitVector result = BitVector.of();
 131                 for (int i = 0; i < 16; i += 4)
 132                 {
 133                         String hlsID = String.format("am2901_%d-%d.%s", (i + 3), i, am2901CellSuffix);
 134                         result = result.concat((BitVector) am2900.getHighLevelState(hlsID));
 135                 }
 136                 return result;
 137         }
 138
 139         @Override
 140         public void setRegister(Register r, BitVector value)
 141         {
 142                 String am2901CellSuffix = getAm2901CellSuffix(r);
 143                 for (int i = 0; i < 16; i += 4)
 144                 {
 145                         String hlsID = String.format("am2901_%d-%d.%s", (i + 3), i, am2901CellSuffix);
 146                         am2900.setHighLevelState(hlsID, value.subVector(i, i + 4));
 147                 }
 148         }
 149
 150         @Override
 151         public void addRegisterListener(Register r, Consumer<BitVector> listener)
 152         {
 153                 Map<Consumer<BitVector>, Consumer<Object>> modelListenersPerRegisterListener = modelListenersPerRegisterListenerPerRegister
 154                                 .computeIfAbsent(r, k -> new HashMap<>());
 155                 if (modelListenersPerRegisterListener.containsKey(listener))
 156                         return;
 157
 158                 Consumer<Object> modelListener = v -> listener.accept(getRegister(r));
 159                 String am2901CellSuffix = getAm2901CellSuffix(r);
 160                 for (int i = 0; i < 16; i += 4)
 161                 {
 162                         String hlsID = String.format("am2901_%d-%d.%s", (i + 3), i, am2901CellSuffix);
 163                         am2900.addHighLevelStateListener(hlsID, modelListener);
 164                 }
 165         }
 166
 167         @Override
 168         public void removeRegisterListener(Register r, Consumer<BitVector> listener)
 169         {
 170                 Map<Consumer<BitVector>, Consumer<Object>> modelListenersPerRegisterListener = modelListenersPerRegisterListenerPerRegister.get(r);
 171                 if (modelListenersPerRegisterListener == null)
 172                         return;
 173
 174                 Consumer<Object> modelListener = modelListenersPerRegisterListener.get(listener);
 175                 if (modelListener == null)
 176                         return;
 177
 178                 String am2901CellSuffix = getAm2901CellSuffix(r);
 179                 for (int i = 0; i < 16; i += 4)
 180                 {
 181                         String hlsID = String.format("am2901_%d-%d.%s", (i + 3), i, am2901CellSuffix);
 182                         am2900.removeHighLevelStateListener(hlsID, modelListener);
 183                 }
 184         }
 185
 186         private static String getAm2901CellSuffix(Register r)
 187         {
 188                 if (r instanceof QRegister)
 189                         return "qreg.q";
 190                 if (r instanceof NumberedRegister)
 191                         return "regs.c" + ((NumberedRegister) r).getIndexAsBitstring() + ".q";
 192                 throw new IllegalArgumentException("Not a register of an Am2900Machine: " + r);
 193         }
 194
 195         @Override
 196         public AssignableMainMemory getMainMemory()
 197         {
 198                 return mainMemory;
 199         }
 200
 201         @Override
 202         public AssignableMicroInstructionMemory getMicroInstructionMemory()
 203         {
 204                 return instMemory;
 205         }
 206
 207         @Override
 208         public long getActiveMicroInstructionAddress()
 209         {
 210                 return activeInstructionAddress;
 211         }
 212
 213         private long getCurrentMicroInstructionAddress()
 214         {
 215                 BitVector vector = (BitVector) am2900.getHighLevelState("mpm_address");
 216                 return vector.isBinary() ? vector.getUnsignedValueLong() : -1;
 217         }
 218
 219         @Override
 220         public void addActiveMicroInstructionChangedListener(ActiveMicroInstructionChangedListener listener)
 221         {
 222                 amicListeners.add(listener);
 223         }
 224
 225         @Override
 226         public void removeActiveMicroInstructionChangedListener(ActiveMicroInstructionChangedListener listener)
 227         {
 228                 amicListeners.remove(listener);
 229         }
 230
 231         private void notifyActiveMicroInstructionChangedListeners(long oldAddress, long newAddress)
 232         {
 233                 amicListeners.forEach(l -> l.instructionChanged(oldAddress, newAddress));
 234         }
 235 }