net.mograsim.logic.ui.am2900/test/net/mograsim/logic/ui/am2900/TestableAm2901Impl.java

   1 package net.mograsim.logic.ui.am2900;
   2
   3 import static org.junit.jupiter.api.Assertions.fail;
   4
   5 import java.lang.reflect.Field;
   6 import java.util.HashMap;
   7 import java.util.HashSet;
   8 import java.util.LinkedList;
   9 import java.util.Objects;
  10 import java.util.Queue;
  11 import java.util.Set;
  12 import java.util.TreeSet;
  13
  14 import net.mograsim.logic.core.components.BitDisplay;
  15 import net.mograsim.logic.core.components.ManualSwitch;
  16 import net.mograsim.logic.core.timeline.Timeline;
  17 import net.mograsim.logic.core.types.Bit;
  18 import net.mograsim.logic.core.types.BitVector;
  19 import net.mograsim.logic.core.types.BitVector.BitVectorMutator;
  20 import net.mograsim.logic.ui.model.ViewModel;
  21 import net.mograsim.logic.ui.model.ViewModelModifiable;
  22 import net.mograsim.logic.ui.model.components.GUIBitDisplay;
  23 import net.mograsim.logic.ui.model.components.GUIComponent;
  24 import net.mograsim.logic.ui.model.components.GUIManualSwitch;
  25 import net.mograsim.logic.ui.model.components.SubmodelComponent;
  26 import net.mograsim.logic.ui.model.components.mi.nandbased.am2901.GUIAm2901;
  27 import net.mograsim.logic.ui.model.wires.GUIWire;
  28 import net.mograsim.logic.ui.modeladapter.LogicModelParameters;
  29 import net.mograsim.logic.ui.modeladapter.ViewLogicModelAdapter;
  30
  31 public class TestableAm2901Impl implements TestableAm2901
  32 {
  33         private GUIAm2901 am2901;
  34         private Timeline timeline;
  35         private ManualSwitch I8, I7, I6, I5, I4, I3, I2, I1, I0;
  36         private ManualSwitch C;
  37         private ManualSwitch Cn;
  38         private ManualSwitch D1, D2, D3, D4;
  39         private ManualSwitch A0, A1, A2, A3;
  40         private ManualSwitch B0, B1, B2, B3;
  41         private ManualSwitch IRAMn, IRAMn_3, IQn, IQn_3;
  42         private BitDisplay Y1, Y2, Y3, Y4;
  43         private BitDisplay F_0, Cn_4, OVR, F3;
  44         private BitDisplay ORAMn, ORAMn_3, OQn, OQn_3;
  45
  46         private Set<String> wireDebugChangeSet;
  47         private boolean debugWires = false;
  48         public int debugEventThreshold = 10_000;
  49         public int debugEventCount = 500;
  50
  51         private int eventCounter;
  52
  53         @Override
  54         public Result run()
  55         {
  56                 // Normal execution until completion or eventLimit
  57                 int eventLimit = debugEventThreshold;
  58                 eventCounter = 0;
  59                 debugWires = false;
  60                 while (eventCounter < eventLimit)
  61                 {
  62                         timeline.executeNext();
  63                         if (!timeline.hasNext())
  64                         {
  65 //                              System.out.println("run() took " + eventCounter + " events");
  66                                 return Result.SUCCESS;
  67                         }
  68                 }
  69                 // Start debugging if event limit is reached
  70                 debugWires = true;
  71                 wireDebugChangeSet = new TreeSet<>();
  72                 Set<String> oldChangeSet;
  73                 // observe wire changes to detect, if we are really stuck in an endless loop
  74                 do
  75                 {
  76                         eventLimit += debugEventCount;
  77                         oldChangeSet = wireDebugChangeSet;
  78                         wireDebugChangeSet = new TreeSet<>();
  79                         while (eventCounter < eventLimit)
  80                         {
  81                                 timeline.executeNext();
  82                                 if (!timeline.hasNext())
  83                                 {
  84                                         // no endless loop, but more events needed than expected
  85                                         System.out.println("run() took longer than expected: " + eventCounter);
  86                                         return Result.SUCCESS;
  87                                 }
  88                         }
  89                 } while (!oldChangeSet.equals(wireDebugChangeSet));
  90                 // if stuck, abort execution and print wires
  91                 System.err.print("Problematic Wire updates:");
  92                 wireDebugChangeSet.forEach(System.out::println);
  93                 System.err.println("run() failed: " + eventCounter);
  94                 return Result.OUT_OF_TIME;
  95         }
  96
  97         @SuppressWarnings("unused")
  98         @Override
  99         public void setup()
 100         {
 101                 // Create view model
 102                 ViewModelModifiable viewModel = new ViewModelModifiable();
 103                 am2901 = new GUIAm2901(viewModel);
 104                 // Get switches
 105                 HashMap<String, GUIManualSwitch> idSwitchMap = new HashMap<>();
 106                 for (String id : am2901.getInputPinNames())
 107                 {
 108                         GUIManualSwitch sw = new GUIManualSwitch(viewModel);
 109                         new GUIWire(viewModel, am2901.getPin(id), sw.getOutputPin());
 110                         idSwitchMap.put(id, sw);
 111                 }
 112                 // Get displays
 113                 HashMap<String, GUIBitDisplay> idDisplayMap = new HashMap<>();
 114                 for (String id : am2901.getOutputPinNames())
 115                 {
 116                         GUIBitDisplay bd = new GUIBitDisplay(viewModel);
 117 //                      bd.addRedrawListener(() -> System.out.println(id + " " + bd.getBitDisplay().getDisplayedValue()));
 118                         new GUIWire(viewModel, am2901.getPin(id), bd.getInputPin());
 119                         idDisplayMap.put(id, bd);
 120                 }
 121                 // Create logic model
 122                 LogicModelParameters params = new LogicModelParameters();
 123                 params.gateProcessTime = 50;
 124                 params.wireTravelTime = 10;
 125                 timeline = ViewLogicModelAdapter.convert(viewModel, params);
 126                 // Bind switches/displays to this test class
 127                 for (var entry : idSwitchMap.entrySet())
 128                         setField(entry.getKey().replaceAll("\\+|=", "_"), entry.getValue().getManualSwitch());
 129                 for (var entry : idDisplayMap.entrySet())
 130                         setField(entry.getKey().replaceAll("\\+|=", "_"), entry.getValue().getBitDisplay());
 131
 132                 // Debug code
 133                 HashSet<GUIWire> wiresIncludingSubmodels = new HashSet<>();
 134                 Queue<ViewModel> modelsToIterate = new LinkedList<>();
 135                 modelsToIterate.add(viewModel);
 136                 while (modelsToIterate.size() > 0)
 137                 {
 138                         ViewModel model = modelsToIterate.poll();
 139                         wiresIncludingSubmodels.addAll(model.getWires());
 140                         for (GUIComponent comp : model.getComponents())
 141                                 if (comp instanceof SubmodelComponent)
 142                                         modelsToIterate.offer(((SubmodelComponent) comp).submodel);
 143                 }
 144                 wiresIncludingSubmodels.forEach(w -> w.addRedrawListener(() ->
 145                 {
 146                         if (debugWires)
 147                         {
 148                                 wireDebugChangeSet.add(w.toString());
 149                         }
 150                 }));
 151                 timeline.addEventAddedListener(te -> eventCounter++);
 152         }
 153
 154         @Override
 155         public void setDest(Am2901_Dest dest)
 156         {
 157                 var bits = of(dest.ordinal(), 3);
 158                 I8.setToValueOf(bits.getBit(0));
 159                 I7.setToValueOf(bits.getBit(1));
 160                 I6.setToValueOf(bits.getBit(2));
 161         }
 162
 163         @Override
 164         public void setFunc(Am2901_Func func)
 165         {
 166                 var bits = of(func.ordinal(), 3);
 167                 I5.setToValueOf(bits.getBit(0));
 168                 I4.setToValueOf(bits.getBit(1));
 169                 I3.setToValueOf(bits.getBit(2));
 170         }
 171
 172         @Override
 173         public void setSrc(Am2901_Src src)
 174         {
 175                 var bits = of(src.ordinal(), 3);
 176                 I2.setToValueOf(bits.getBit(0));
 177                 I1.setToValueOf(bits.getBit(1));
 178                 I0.setToValueOf(bits.getBit(2));
 179         }
 180
 181         @Override
 182         public void setReg_A(String val_4_bit)
 183         {
 184                 // reverse because the BitVector.parse() expects the LSBit at the beginning and the MSBit at the end
 185                 var bits = BitVector.parse(new StringBuilder(val_4_bit).reverse().toString());
 186                 A3.setToValueOf(bits.getBit(3));
 187                 A2.setToValueOf(bits.getBit(2));
 188                 A1.setToValueOf(bits.getBit(1));
 189                 A0.setToValueOf(bits.getBit(0));
 190         }
 191
 192         @Override
 193         public void setReg_B(String val_4_bit)
 194         {
 195                 // reverse because the BitVector.parse() expects the LSBit at the beginning and the MSBit at the end
 196                 var bits = BitVector.parse(new StringBuilder(val_4_bit).reverse().toString());
 197                 B3.setToValueOf(bits.getBit(3));
 198                 B2.setToValueOf(bits.getBit(2));
 199                 B1.setToValueOf(bits.getBit(1));
 200                 B0.setToValueOf(bits.getBit(0));
 201         }
 202
 203         @Override
 204         public void setCarryIn(String val_1_bit)
 205         {
 206                 Cn.setToValueOf(Bit.parse(val_1_bit));
 207         }
 208
 209         @Override
 210         public void setNotOutEnable(String val_1_bit)
 211         {
 212                 throw new UnsupportedOperationException(); // TODO
 213         }
 214
 215         @Override
 216         public void setD(String val_4_bit)
 217         {
 218                 // reverse because the BitVector.parse() expects the LSBit at the beginning and the MSBit at the end
 219                 var bits = BitVector.parse(new StringBuilder(val_4_bit).reverse().toString());
 220                 D4.setToValueOf(bits.getBit(3));
 221                 D3.setToValueOf(bits.getBit(2));
 222                 D2.setToValueOf(bits.getBit(1));
 223                 D1.setToValueOf(bits.getBit(0));
 224         }
 225
 226         @Override
 227         public void setQ_0(String val_1_bit)
 228         {
 229                 IQn.setToValueOf(Bit.parse(val_1_bit));
 230         }
 231
 232         @Override
 233         public void setQ_3(String val_1_bit)
 234         {
 235                 IQn_3.setToValueOf(Bit.parse(val_1_bit));
 236         }
 237
 238         @Override
 239         public void setRAM_0(String val_1_bit)
 240         {
 241                 IRAMn.setToValueOf(Bit.parse(val_1_bit));
 242         }
 243
 244         @Override
 245         public void setRAM_3(String val_1_bit)
 246         {
 247                 IRAMn_3.setToValueOf(Bit.parse(val_1_bit));
 248         }
 249
 250         @Override
 251         public void clockOn(boolean isClockOn)
 252         {
 253                 C.setState(isClockOn);
 254         }
 255
 256         @Override
 257         public String getQ_0()
 258         {
 259                 return OQn.getDisplayedValue().toString();
 260         }
 261
 262         @Override
 263         public String getQ_3()
 264         {
 265                 return OQn_3.getDisplayedValue().toString();
 266         }
 267
 268         @Override
 269         public String getRAM_0()
 270         {
 271                 return ORAMn.getDisplayedValue().toString();
 272         }
 273
 274         @Override
 275         public String getRAM_3()
 276         {
 277                 return ORAMn_3.getDisplayedValue().toString();
 278         }
 279
 280         @Override
 281         public String getNotP()
 282         {
 283                 throw new UnsupportedOperationException(); // TODO
 284         }
 285
 286         @Override
 287         public String getNotG()
 288         {
 289                 throw new UnsupportedOperationException(); // TODO
 290         }
 291
 292         @Override
 293         public String getCarryOut()
 294         {
 295                 return Cn_4.getDisplayedValue().toString();
 296         }
 297
 298         @Override
 299         public String getSign()
 300         {
 301                 return F3.getDisplayedValue().toString();
 302         }
 303
 304         @Override
 305         public String getZero()
 306         {
 307                 return F_0.getDisplayedValue().toString();
 308         }
 309
 310         @Override
 311         public String getOverflow()
 312         {
 313                 return OVR.getDisplayedValue().toString();
 314         }
 315
 316         @Override
 317         public String getY()
 318         {
 319                 var y3 = Y4.getDisplayedValue();
 320                 var y2 = Y3.getDisplayedValue();
 321                 var y1 = Y2.getDisplayedValue();
 322                 var y0 = Y1.getDisplayedValue();
 323                 // reverse because BitVector.toString() returns the LSBit at the beginning and the MSBit at the end
 324                 return new StringBuilder(y0.concat(y1).concat(y2).concat(y3).toString()).reverse().toString();
 325         }
 326
 327         private void setField(String name, Object value)
 328         {
 329                 try
 330                 {
 331                         Field f = TestableAm2901Impl.class.getDeclaredField(name);
 332                         f.setAccessible(true);
 333                         f.set(this, Objects.requireNonNull(value));
 334                 }
 335                 catch (Exception e)
 336                 {
 337                         fail(e);
 338                 }
 339         }
 340
 341         private static BitVector of(int value, int length)
 342         {
 343                 BitVectorMutator mutator = BitVectorMutator.ofLength(length);
 344                 int val = value;
 345                 for (int i = length - 1; i >= 0; i--)
 346                 {
 347                         mutator.setBit(i, Bit.lastBitOf(val));
 348                         val >>>= 1;
 349                 }
 350                 return mutator.toBitVector();
 351         }
 352
 353         @Override
 354         public void setDirectly(Register r, String val_4_bit)
 355         {
 356                 // reverse because the BitVector.parse() expects the LSBit at the beginning and the MSBit at the end
 357                 am2901.setHighLevelState(regToStateID(r), BitVector.parse(new StringBuilder(val_4_bit).reverse().toString()));
 358         }
 359
 360         @Override
 361         public String getDirectly(Register r)
 362         {
 363                 // reverse because BitVector.toString() returns the LSBit at the beginning and the MSBit at the end
 364                 return new StringBuilder(am2901.getHighLevelState(regToStateID(r)).toString()).reverse().toString();
 365         }
 366
 367         private static String regToStateID(Register r)
 368         {
 369                 if (r == Register.Q)
 370                         return "qreg.q";
 371                 return "regs.c" + r.toBitString() + ".q";
 372         }
 373 }