sim.java

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

		int strength = nodeHead.newStrength;

		// print state of signal if this signal is being traced
		if (tracing)
		{
			System.out.println("  Formerly " + strengthDesc[nodeHead.sumStrength] + stateDesc[nodeHead.sumState+3] +
				", starts at " + strengthDesc[strength] + stateDesc[state+3]);
		}

		// look at all factors affecting the node
		for(Stat statHead : nodeHead.statList)
		{
			int thisState = statHead.newState;
			int thisStrength = statHead.newStrength;
			if (tracing)
				System.out.println("    " + strengthDesc[thisStrength] + stateDesc[thisState+3] +
					" from " + statHead.primPtr.name + statHead.primPtr.level);

			// higher strength overrides previous node state
			if (thisStrength > strength)
			{
				state = thisState;
				strength = thisStrength;
				continue;
			}

			// same strength: must arbitrate
			if (thisStrength == strength)
			{
				if (thisState != state)
					state = Stimuli.LOGIC_X;
			}
		}

		// if the node has nothing driving it, set it to the old value
		if (strength == Stimuli.OFF_STRENGTH)
		{
			state = nodeHead.sumState;
			strength = Stimuli.NODE_STRENGTH;
		}

		// stop now if node state did not change
		if (nodeHead.sumState == state && nodeHead.sumStrength == strength)
		{
			if (tracing) System.out.println("    NO CHANGE");
			return;
		}

		if (nodeHead.sig != null)
		{
			List<ALS.Trak> nodeData = tracking.get(nodeHead);
			if (nodeData == null)
			{
				nodeData = new ArrayList<ALS.Trak>();
				tracking.put(nodeHead, nodeData);
			}

			ALS.Trak trakHead = new ALS.Trak();
			trakHead.state = state | strength;
			trakHead.time = als.timeAbs;
			nodeData.add(trakHead);
		}
		if (tracing)
			System.out.println("    BECOMES " + strengthDesc[strength] + stateDesc[state+3]);

		nodeHead.sumState = state;
		nodeHead.sumStrength = strength;
		nodeHead.tLast = als.timeAbs;

		als.driveNode = nodeHead;
		for(Load l : nodeHead.pinList)
			chekList.add(l);
	}

	/**
	 * Method to examine the truth tables for the transitions that are
	 * specified in the checking list.  If there is a match between a truth table
	 * entry and the state of the logic network the transition is scheduled
	 * for firing.  Returns true on error.
	 */
	private boolean scheduleNewEvents()
	{
		// make a copy of the event list, and clear the main list
		List<Load> chekListCopy =  new ArrayList<Load>();
		for(Load l : chekList)
			chekListCopy.add(l);
		chekList.clear();

		for(Load chekHead : chekListCopy)
		{
			ALS.Model primHead = (ALS.Model)chekHead.ptr;
			if (primHead.type == 'F')
			{
				ALS.Func funcHead = (ALS.Func)primHead.ptr;
				funcHead.procPtr.simulate(primHead);
				continue;
			}

			for (ALS.Row rowHead = (ALS.Row)primHead.ptr; rowHead != null; rowHead = rowHead.next)
			{
				int flag = 1;
				for(Object obj : rowHead.inList)
				{
					ALS.IO ioHead = (ALS.IO)obj;
					int operatr = ioHead.operatr;
					int operand;
					if (operatr < 128)
					{
						operand = ((Integer)ioHead.operand).intValue();
					} else
					{
						operatr -= 128;
						ALS.Node nodeHead = (ALS.Node)ioHead.operand;
						operand = nodeHead.sumState;
					}

					switch (operatr)
					{
						case '=':
							if (((ALS.Node)ioHead.nodePtr).sumState != operand) flag = 0;
							break;
						case '!':
							if (((ALS.Node)ioHead.nodePtr).sumState == operand) flag = 0;
							break;
						case '<':
							if (((ALS.Node)ioHead.nodePtr).sumState >= operand) flag = 0;
							break;
						case '>':
							if (((ALS.Node)ioHead.nodePtr).sumState <= operand) flag = 0;
							break;
						default:
							System.out.println("Invalid logical operator: " + operatr);
							return true;
					}

					if (flag == 0) break;
				}

				if (flag != 0)
				{
					calculateEventTime(primHead, rowHead);
					break;
				}
			}
		}
		return false;
	}

	/**
	 * Method to calculate the time when the next occurance of a set of
	 * clock vectors is to be added to the event scheduling linklist.
	 *
	 * Calling Arguments:
	 *	linkHead = pointer to the link element to be reinserted into the list
	 *  rowHead  = pointer to a row element containing timing information
	 */
	private void calculateClockTime(ALS.Link linkHead, ALS.Row rowHead)
	{
		double time = als.timeAbs;

		if (rowHead.delta != 0) time += rowHead.delta;
		if (rowHead.linear != 0)
		{
			double prob = Math.random();
			time += 2.0 * prob * rowHead.linear;
		}

		/*
		 * if (rowHead.exp)
		 * {
		 * 	prob = rand() / MAXINTBIG;
		 * 	time += (-log(prob) * (rowHead.exp));
		 * }
		 */

		linkHead.time = time;
		insertLinkList(linkHead);
	}

	/**
	 * Method to calculate the time of occurance of an event and then
	 * places an entry into the event scheduling linklist for later execution.
	 * Returns true on error.
	 *
	 * Calling Arguments:
	 *	primHead  = pointer to the primitive to be scheduled for firing
	 *	rowHead  = pointer to the row containing the event to be scheduled
	 */
	private void calculateEventTime(ALS.Model primHead, ALS.Row rowHead)
	{
		double time = 0.0;
		int priority = primHead.priority;

		if (rowHead.delta != 0) time += rowHead.delta;
		if (rowHead.abs != 0) time += rowHead.abs;
		if (rowHead.linear != 0)
		{
			double prob = Math.random();
			time += 2.0 * prob * rowHead.linear;
		}

		/*
		 * if (rowHead.exp)
		 * {
		 * 	prob = rand() / MAXINTBIG;
		 * 	time += (-log(prob) * (rowHead.exp));
		 * }
		 */

		if (rowHead.random != 0)
		{
			double prob = Math.random();
			if (prob <= rowHead.random)
			{
				priority = -1;
			}
		}

		if (primHead.fanOut != 0)
		{
			Iterator<Object> it = rowHead.outList.iterator();
			ALS.IO ioPtr = (ALS.IO)it.next();
			ALS.Stat statHead = (ALS.Stat)ioPtr.nodePtr;
			time *= statHead.nodePtr.load;
		}
		time += als.timeAbs;

		for(Object obj : rowHead.outList)
		{
			ALS.IO ioHead = (ALS.IO)obj;
			ALS.Stat statHead = (ALS.Stat)ioHead.nodePtr;
			if (statHead.schedOp == ioHead.operatr &&
				statHead.schedState.equals(ioHead.operand) &&
				statHead.schedStrength == ioHead.strength)
			{
				continue;
			}

			ALS.Link linkPtr2 = new ALS.Link();
			linkPtr2.type = 'G';
			linkPtr2.ptr = statHead;
			linkPtr2.operatr = statHead.schedOp = ioHead.operatr;
			linkPtr2.state = statHead.schedState = ioHead.operand;
			linkPtr2.strength = statHead.schedStrength = ioHead.strength;
			linkPtr2.time = time;
			linkPtr2.priority = priority;
			linkPtr2.primHead = primHead;
			if (tracing)
			{
				System.out.println("      Schedule(G): " + statHead.primPtr.name + statHead.primPtr.level +
					" at " + TextUtils.convertToEngineeringNotation(time));
			}
			insertLinkList(linkPtr2);
		}
	}

	/**
	 * Method to insert a data element into a linklist that is 2
	 * dimensionally sorted first 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 insertLinkList(ALS.Link linkHead)
	{
		// linkPtr1Is: 0: ALS.linkBack  1: linkPtr2.up  2: linkPtr2.left
		int linkPtr1Is = 0;
		ALS.Link linkPtr2 = als.linkBack;
		ALS.Link linkPtr2Val = linkPtr2;
		ALS.Link linkPtr3 = null;
		for(;;)
		{
			if (linkPtr2 == null)
			{
				als.linkFront = linkHead;
				switch (linkPtr1Is)
				{
					case 0: als.linkBack = linkHead;      break;
					case 1: linkPtr2Val.up = linkHead;    break;
					case 2: linkPtr2Val.left = linkHead;  break;
				}
				linkHead.left = null;
				linkHead.right = linkPtr3;
				linkHead.up = linkHead;
				linkHead.down = null;
				return;
			}

			if (linkPtr2.time < linkHead.time)
			{
				linkPtr2.right = linkHead;
				switch (linkPtr1Is)
				{
					case 0: als.linkBack = linkHead;      break;
					case 1: linkPtr2Val.up = linkHead;    break;
					case 2: linkPtr2Val.left = linkHead;  break;
				}
				linkHead.left = linkPtr2;
				linkHead.right = linkPtr3;
				linkHead.up = linkHead;
				linkHead.down = null;
				return;
			}

			if (linkPtr2.time == linkHead.time)
			{
				if (linkPtr2.priority > linkHead.priority)
				{
					linkHead.left = linkPtr2.left;
					linkHead.right = linkPtr2.right;
					linkHead.down = linkPtr2;
					linkHead.up = linkPtr2.up;
					linkPtr2.up = linkHead;
					switch (linkPtr1Is)
					{
						case 0: als.linkBack = linkHead;      break;
						case 1: linkPtr2Val.up = linkHead;    break;
						case 2: linkPtr2Val.left = linkHead;  break;
					}
					if (linkHead.left != null)
					{
						linkHead.left.right = linkHead;
					} else
					{
						als.linkFront = linkHead;
					}
					return;
				}

				linkPtr1Is = 1;
				linkPtr2Val = linkPtr2;
				linkPtr2 = linkPtr2.up;
				linkPtr3 = null;
				for(;;)
				{
					if (linkPtr2.priority <= linkHead.priority)
					{
						linkPtr2.down = linkHead;
						switch (linkPtr1Is)
						{
							case 0: als.linkBack = linkHead;      break;
							case 1: linkPtr2Val.up = linkHead;    break;
							case 2: linkPtr2Val.left = linkHead;  break;
						}
						linkHead.up = linkPtr2;
						linkHead.down = linkPtr3;
						return;
					}

					linkPtr3 = linkPtr2;
					linkPtr1Is = 1;
					linkPtr2Val = linkPtr2;
					linkPtr2 = linkPtr2.up;
				}
			}

			linkPtr3 = linkPtr2;
			linkPtr1Is = 2;
			linkPtr2Val = linkPtr2;
			linkPtr2 = linkPtr2.left;
		}
	}
}