als.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

				", Strength = " + Stimuli.describeStrength(nodeHead.newStrength));
			for(Stat statHead : nodeHead.statList)
			{
				s1 = Stimuli.describeLevel(statHead.newState);
				System.out.println("Primitive " + statHead.primPtr.name + ":    State = " + s1 +
					", Strength = " + Stimuli.describeStrength(statHead.newStrength));
			}
		}
	}

	/**
	 * Method to remove all stimuli from the currently-selected signals.
	 */
	public void removeStimuliFromSignal()
	{
		List<Signal> signals = ww.getHighlightedNetworkNames();
		if (signals.size() == 0)
		{
			Job.getUserInterface().showErrorMessage("Must select a signal on which to clear stimuli",
				"No Signals Selected");
			return;
		}
		for(Signal sig : signals)
		{
			sig.clearControlPoints();

			Link lastSet = null;
			Link nextSet = null;
			for(Link thisSet = setRoot; thisSet != null; thisSet = nextSet)
			{
				nextSet = thisSet.right;
				boolean delete = false;
				if (thisSet.ptr instanceof Node)
				{
					Node node = (Node)thisSet.ptr;
					if (node.sig == sig) delete = true;
				} else if (thisSet.ptr instanceof Row)
				{
					Row clokHead = (Row)thisSet.ptr;
					Iterator<Object> cIt = clokHead.inList.iterator();
					if (cIt.hasNext())
					{
						Link vectHead = (Link)cIt.next();
						Node node = (Node)vectHead.ptr;
						if (node.sig == sig) delete = true;
					}
				}
				if (delete)
				{
					if (lastSet == null) setRoot = nextSet; else
						lastSet.right = nextSet;
				} else
				{
					lastSet = thisSet;
				}
			}
		}
		if (Simulation.isBuiltInResimulateEach())
		{
			theSim.initializeSimulator(true);
		}
	}

	/**
	 * Method to remove the selected stimuli.
	 */
	public void removeSelectedStimuli()
	{
		boolean found = false;
		for(Iterator<Panel> it = ww.getPanels(); it.hasNext(); )
		{
			Panel wp = it.next();
			for(WaveSignal ws : wp.getSignals())
			{
				if (!ws.isHighlighted()) continue;
				double [] selectedCPs = ws.getSelectedControlPoints();
				if (selectedCPs == null) continue;
				for(int i=0; i<selectedCPs.length; i++)
				{
					Signal sig = ws.getSignal();
					Link lastSet = null;
					Link nextSet = null;
					for(Link thisSet = setRoot; thisSet != null; thisSet = nextSet)
					{
						nextSet = thisSet.right;
						boolean delete = false;
						if (thisSet.time == selectedCPs[i])
						{
							if (thisSet.ptr instanceof Node)
							{
								Node node = (Node)thisSet.ptr;
								if (node.sig == sig) delete = true;
							} else if (thisSet.ptr instanceof Row)
							{
								Row clokHead = (Row)thisSet.ptr;
								Iterator<Object> cIt = clokHead.inList.iterator();
								if (cIt.hasNext())
								{
									Link vectHead = (Link)cIt.next();
									Node node = (Node)vectHead.ptr;
									if (node.sig == sig) delete = true;
								}
							}
						}
						if (delete)
						{
							sig.removeControlPoint(thisSet.time);
							if (lastSet == null) setRoot = nextSet; else
								lastSet.right= nextSet;
							found = true;
							break;
						}

						lastSet = thisSet;
					}
				}
			}
		}
		if (!found)
		{
			System.out.println("There are no selected control points to remove");
			return;
		}
		if (Simulation.isBuiltInResimulateEach())
		{
			theSim.initializeSimulator(true);
		}
	}

	/**
	 * Method to remove all stimuli from the simulation.
	 */
	public void removeAllStimuli()
	{
		clearAllVectors(false);
		for(Iterator<Panel> it = ww.getPanels(); it.hasNext(); )
		{
			Panel wp = it.next();
			for(WaveSignal ws : wp.getSignals())
			{
				Signal sig = ws.getSignal();
				sig.clearControlPoints();
			}
		}
		if (Simulation.isBuiltInResimulateEach())
		{
			theSim.initializeSimulator(true);
		}
	}

	/**
	 * Method to save the current stimuli information to disk.
	 */
	public void saveStimuli()
	{
		String stimuliFileName = OpenFile.chooseOutputFile(FileType.ALSVECTOR, "ALS Vector file", an.getStimuli().getCell().getName() + ".vec");
		if (stimuliFileName ==  null) return;
		try
		{
			PrintWriter printWriter = new PrintWriter(new BufferedWriter(new FileWriter(stimuliFileName)));
			List<String> stimuliList = getStimuliToSave();
			for(String str : stimuliList)
				printWriter.println(str);
			printWriter.close();
		} catch (IOException e)
		{
			System.out.println("Error writing results");
			return;
		}
		System.out.println("Wrote " + stimuliFileName);
	}

	/**
	 * Method to restore the current stimuli information from disk.
	 */
	public void restoreStimuli()
	{
		String stimuliFileName = OpenFile.chooseInputFile(FileType.ALSVECTOR, "ALS Vector file");
		if (stimuliFileName == null) return;
		List<String> stimuliList = new ArrayList<String>();
		URL url = TextUtils.makeURLToFile(stimuliFileName);
		try
		{
			URLConnection urlCon = url.openConnection();
			InputStreamReader is = new InputStreamReader(urlCon.getInputStream());
			LineNumberReader lineReader = new LineNumberReader(is);
			for(;;)
			{
				String s1 = lineReader.readLine();
				if (s1 == null) break;
				stimuliList.add(s1);
			}
			lineReader.close();
		} catch (IOException e)
		{
			System.out.println("Error reading " + stimuliFileName);
			return;
		}

		processStimuliList(stimuliList);
	}

	/********************************** INTERFACE SUPPORT **********************************/

	private void init()
	{
		// create the user-defined functions
		new UserCom.PMOSTran(this);
		new UserCom.PMOSTranWeak(this);
		new UserCom.NMOSTran(this);
		new UserCom.NMOSTranWeak(this);
		new UserCom.JKFlop(this);
		new UserCom.DFFlop(this);
		new UserCom.BusToState(this);
		new UserCom.StateToBus(this);

		// not used:
//		new UserCom.Counter();
//		new UserCom.DelayCalc();
//		new UserCom.FIFO();
//		new UserCom.RXData();
//		new UserCom.AFRegisters();
//		new UserCom.ControlLogic();
//		new UserCom.Mod2Adder();
//		new UserCom.AboveAdder();
//		new UserCom.Bus12ToState();

		// allocate memory
		if (instBuf == null)
			instBuf = new char[iBufSize=100];
		if (instPtr == null)
			instPtr = new int[iPtrSize=100];
	}

	private void doSimulation(Cell netlistCell, Cell cell, WaveformWindow oldWW, List<String> stimuliList)
	{
		// initialize memory
		init();

		// read netlist
		eraseModel();
		if (readNetDesc(netlistCell)) return;
		if (theFlat.flattenNetwork(cell)) return;

		// initialize display
		an = getCircuit(cell);
		ww = oldWW;

		Simulation.showSimulationData(an.getStimuli(), ww);

		// make a waveform window
		if (ww == null)
			ww = an.getStimuli().getWaveformWindow();

		if (stimuliList != null) processStimuliList(stimuliList);

		// run simulation
		theSim.initializeSimulator(true);
	}

	private void makeThemThus(int state)
	{
		List<Signal> signals = ww.getHighlightedNetworkNames();
		if (signals.size() == 0)
		{
			Job.getUserInterface().showErrorMessage("Must select a signal on which to set stimuli",
				"No Signals Selected");
			return;
		}
		for(Signal sig : signals)
		{
			String sigName = sig.getFullName();
			Node nodeHead = findNode(sigName);
			if (nodeHead == null)
			{
				System.out.println("ERROR: Unable to find node " + sigName);
				return;
			}

			int strength = Stimuli.NODE_STRENGTH;
			double time = ww.getMainXPositionCursor();

			Link setHead = new Link();
			setHead.type = 'N';
			setHead.ptr = nodeHead;
			setHead.state = new Integer(state);
			setHead.strength = strength;
			setHead.priority = 2;
			setHead.time = time;
			setHead.right = null;
			sig.addControlPoint(time);
			insertSetList(setHead);

//			System.out.println("Node '" + sigName + "' scheduled, state = " + state +
//				", strength = " + Stimuli.describeStrength(strength) + ", time = " + time);
		}

		if (Simulation.isBuiltInResimulateEach())
		{
			double endTime = theSim.initializeSimulator(true);
			if (Simulation.isBuiltInAutoAdvance()) ww.setMainXPositionCursor(endTime);
		}
	}

	/**
	 * Method to insert a data element into a linklist that is sorted
	 * by time and then priority.  This link list is used to schedule events
	 * for the simulation.
	 *
	 * Calling Arguments:
	 *	linkHead = pointer to the data element that is going to be inserted
	 */
	void insertSetList(Link linkHead)
	{
		// linkPtr1Is: 0: ALS.setRoot  1: linkptr1.right
		int linkPtr1Is = 0;
		Link linkPtr1 = null;

		for(;;)
		{
			Link linkPtr2 = setRoot;
			if (linkPtr1Is == 1) linkPtr2 = linkPtr1.right;
			if (linkPtr2 == null)
			{
				if (linkPtr1Is == 0) setRoot = linkHead; else
					linkPtr1.right = linkHead;
				break;
			}
			if (linkPtr2.time > linkHead.time || (linkPtr2.time == linkHead.time &&
				linkPtr2.priority > linkHead.priority))
			{
				linkHead.right = linkPtr2;
				if (linkPtr1Is == 0) setRoot = linkHead; else
					linkPtr1.right = linkHead;
				break;
			}
			linkPtr1 = linkPtr2;
			linkPtr1Is = 1;
		}
	}

	private void eraseModel()
	{
		// reset miscellaneous simulation variables
		linkFront = null;
		linkBack = null;

		// delete all test vectors
		clearAllVectors(true);

		// delete all cells in flattened network
		cellRoot = null;

		// delete all nodes in flattened network
		nodeList = new ArrayList<Node>();

		// delete all primitives in flattened network
		primList = new ArrayList<Model>();

		// delete each model/gate/function in hierarchical description
		modelList = new ArrayList<Model>();
	}

	/**
	 * Method to clear all test vectors (even the power and ground vectors if "pwrGnd"
	 * is true).
	 */
	private void clearAllVectors(boolean pwrGnd)
	{
		Link lastSet = null;
		Link nextSet = null;
		for(Link thisSet = setRoot; thisSet != null; thisSet = nextSet)
		{
			nextSet = thisSet.right;
			if (pwrGnd || thisSet.strength != Stimuli.VDD_STRENGTH)
			{
				if (lastSet == null) setRoot = nextSet; else
					lastSet.right= nextSet;
			} else
			{
				lastSet = thisSet;
			}
		}
	}

	private DigitalAnalysis getCircuit(Cell cell)
	{
		// convert the stimuli
		Stimuli sd = new Stimuli();
		sd.setDataType(FileType.ALS);
		sd.setEngine(this);
		DigitalAnalysis an = new DigitalAnalysis(sd, true);
		sd.setSeparatorChar('.');
		sd.setCell(cell);
		String topLevelName = cell.getName().toUpperCase();
		for(Connect cr = cellRoot; cr != null; cr = cr.next)
		{
			if (cr.modelName.equals(topLevelName))
			{
				addExports(cr, an, null);
				break;
			}
		}
		return an;
	}

	private void addExports(Connect cr, DigitalAnalysis an, String context)
	{
		// determine type of model
		for(Model modPtr1 : modelList)
		{
			if (modPtr1.name.equals(cr.modelName))
			{
				if (modPtr1.type != 'M') return;
				break;
			}
		}
		for(ALSExport e : cr.exList)
		{
			if (e.nodePtr.sig != null) continue;
			DigitalSignal sig = new DigitalSignal(an);
			e.nodePtr.sig = sig;
			sig.setSignalName((String)e.nodeName, context);
			sig.buildTime(2);
			sig.buildState(2);
			sig.setTime(0, 0);
			sig.setTime(1, DEFTIMERANGE);
			sig.setState(0, 0);
			sig.setState(1, 0);
		}
		String subContext = context;
		if (subContext == null) subContext = ""; else subContext += ".";
		for(Connect child = cr.child; child != null; child = child.next)
		{
			addExports(child, an, subContext + child.instName);
		}
	}

	private List<String> getStimuliToSave()
	{
		List<String> stimuliList = new ArrayList<String>();
		for (Link setHead = setRoot; setHead != null; setHead = setHead.right)
		{
			switch (setHead.type)
			{
				case 'C':
					Row clokHead = (Row)setHead.ptr;
					List<Object> vectList = clokHead.inList;
					boolean first = true;
					for(Object obj : vectList)
					{
						Link vectHead = (Link)obj;
						if (first)
						{
							String s1 = computeNodeName((Node)vectHead.ptr);
							stimuliList.add("CLOCK " + s1 + " D=" + clokHead.delta + " L=" + clokHead.linear +
								" E=" + clokHead.exp + " STRENGTH=" + Stimuli.strengthToIndex(vectHead.strength) + " TIME=" + setHead.time + " CYCLES=" + setHead.state);
							first = false;
						}
						String s2 = Stimuli.describeLevelBriefly(((Integer)vectHead.state).intValue());
						stimuliList.add("  " + s2 + " " + vectHead.time);
					}
					break;
				case 'N':
					String s1 = computeNodeName((Node)setHead.ptr);
					String s2 = Stimuli.describeLevelBriefly(((Integer)setHead.state).intValue());
					stimuliList.add("SET " + s1 + "=" + s2 + "@" + Stimuli.strengthToIndex(setHead.strength) + " TIME=" + setHead.time);
			}
		}
		return stimuliList;
	}

	private void processStimuliList(List<String> stimuliList)
	{
		// clear all vectors
		while (setRoot != null)
		{
			setRoot = setRoot.right;
		}
		for(Iterator<Panel> it = ww.getPanels(); it.hasNext(); )
		{
			Panel wp = it.next();
			for(WaveSignal ws : wp.getSignals())
			{
				Signal sig = ws.getSignal();
				sig.clearControlPoints();
			}
		}

		boolean flag = true;
		String [] parts = null;
		Iterator<String> sIt = stimuliList.iterator();
		for(;;)
		{
			String s1 = null;
			if (flag)
			{
				if (!sIt.hasNext())
				{
					theSim.initializeSimulator(true);
					break;
				}
				s1 = sIt.next();
				s1 = s1.toUpperCase();
				parts = fragmentCommand(s1);
			}
			flag = true;
			if (parts == null || parts.length < 1) continue;

			String command = parts[0];
			if (command.equals("CLOCK"))
			{
				if (parts.length < 14)
				{
					System.out.println("Error: CLOCK stimuli line has only " + parts.length + " fields: " + s1);
					continue;
				}
				String nodeName = parts[1];
				Node nodeHead = findNode(nodeName);
				if (nodeHead == null)
				{
					System.out.println("ERROR: Unable to find node " + nodeName);
					continue;
				}
				int strength = Stimuli.indexToStrength(TextUtils.atoi(parts[9]));

				Link setHead = new Link();
				setHead.type = 'C';
				Row clokHead = new Row();
				setHead.ptr = clokHead;
				setHead.state = new Integer(TextUtils.atoi(parts[13]));
				setHead.priority = 1;
				setHead.time = TextUtils.atof(parts[11]);
				setHead.right = null;
				insertSetList(setHead);
				if (nodeHead.sig != null)
					nodeHead.sig.addControlPoint(setHead.time);

				clokHead.delta = TextUtils.atof(parts[3]);
				clokHead.linear = TextUtils.atof(parts[5]);
				clokHead.exp = TextUtils.atof(parts[7]);
				clokHead.abs = 0;
				clokHead.random = 0;
				clokHead.next = null;
				clokHead.delay = null;

				clokHead.inList = new ArrayList<Object>();
				for(;;)
				{
					if (!sIt.hasNext())
					{
						theSim.initializeSimulator(false);
						return;
					}
					s1 = sIt.next();
					parts = fragmentCommand(s1.toUpperCase());
					String com = parts[0];
					if (com.equals("CLOCK") || com.equals("SET"))
					{
						flag = false;
						break;
					}
					Link vectPtr2 = new Link();