JHDL 0.3.39

| JHDL Doc Home Page | User's Manual Home Page |


Advanced Topics

The section will discuss two features of JHDL: Behavioral modeling and the marking of cells to determine their visibility in simulation and netlists.

Behavioral Modeling in JHDL

JHDL allows the user to write an optional behavioral model for any Structural cell. This capability is provided primarily to help improve simulation performance. Simulation time is generally much faster for a high-level behavioral model written in Java than for a cell that is modeled strictly structurally, i.e., as a collection of leaf cells and wires.

Modeling Methods (used to create JHDL behavioral simulation models)


There are four methods that implement and enable behavioral models in JHDL Structural (Logic) cells. These are:

If your circuit is purely synchronous, you will need to implement the clock() and reset() methods. A purely asynchronous circuit need only implement the propagate() method. If the circuit you are modeling contains both synchronous and asynchronous behavior, then you will need to implement all three methods. In some cases it may be necessary to individually enable or disable the clock() or propagate() methods when implementing module generators. For example, the designer of a module generator may wish to provide both registered and non-registered versions of a multiplier. When the registered version of the multiplier is desired, the clock() method must be enabled and the propagate method must be disabled. If a non-registered version of the multiplier is desired, the clock() method must be disabled and the propagate() method must be enabled. The following methods are defined on Structural (Logic) cells and provide this capability. Note that you are not allowed to simultaneously disable the clock() and propagate() method -- at least one of these methods must be enabled. An exception will be thrown if you attempt to disable both the clock() and propagate() methods.

Controlling Which Model is Used for Simulation

There are 4 methods supplied that can be used written directly into your Java code to control what is simulated behaviorally and what is simulated structurally. All of these methods are defined on Cells. These methods are: If you are using Jab, then you can control the behavioral state of any cell at runtime by using the Jab GUI (look here for more information), or the behave command (look here for more information) and do not need to build the calls directly into your Java code.

General Strategy

When writing behavioral models, the class will need to keep references to all the wires connected in the connect() calls. You must keep references to the wires returned from the connect() calls. If you do not do this, then you will not be able to read or write the wires.. To read and write wires, you use the get() and put() methods, respectively. There are many different versions of these methods, depending on your wire width. Please refer to the Wire API documentation to find more information on these calls: get, getA, getB, getBV, put, putA, putB, and putBV

Example

The following is an example of a simple behavioral model of a cell with four inputs a, b, c and d and one output e. The circuit implements the following function: ab or cd.
import byucc.jhdl.base.*;
import byucc.jhdl.Logic.*;

public class BehavioralTest extends Logic {

  public static CellInterface[] cell_interface = {
    in("a",1),
    in("b",1),
    in("c",1),
    in("d",1),
    out("e",1)
  };

  private Wire a,b,c,d,e;

  protected boolean defaultSimulationModelIsBehavioral(){
    return true;
  }

  /* The no_register flag, if true, will create a combinatorial
     version of the circuit. If false, will create a registered
     version of the circuit
 */

  BehavioralTest(Node parent, Wire a, Wire b, Wire c, Wire d, Wire e,
                 String name, boolean no_register, boolean force_exception){

    super(parent,name);
    this.a = connect("a",a);
    this.b = connect("b",b);
    this.c = connect("c",c);
    this.d = connect("d",d);
    this.e = connect("e",e);

    if (force_exception){
    // this will disable both of them, which should throw an exception.
      clockMethodIsDisabled(true);
      propagateMethodIsDisabled(true);
    }

    if (!no_register){
      reg_o(or(and(a,b),and(c,d)),e);
      clockMethodIsDisabled(false);
      propagateMethodIsDisabled(true);
    }
    else{
      or_o(and(a,b),and(c,d),e);
      clockMethodIsDisabled(true);
      propagateMethodIsDisabled(false);
    }
  }

  public void clock() {
    e.put(this,(a.get(this) & b.get(this)) | (c.get(this) & d.get(this)));
  }

  public void propagate(){
    e.put(this,(a.get(this) & b.get(this)) | (c.get(this) & d.get(this)));
  }

  public void reset(){
    e.put(this,0);
  }
}

Non-simulateable and Non-netlistable Cells

In come cases, it is useful to flag a cell as non-simulateable or non-netlistable. This is useful when one structural cell is to be used for simulation, and another is used for netlisting.

Many JHDL library cells that cannot be simulated effectively are marked as non-simulateable. All cells built in the library in such a situation have already been flagged appropriately. For example, an FMAP cell (that controls LUT packing) does not need to be simulated, but must be netlisted.

On rare occasions, it is necessary to work have a structural simulation model and a separate, different, netlisting model. In this case, these properties can be set directly on a cell.


| JHDL Doc Home Page | User's Manual Home Page |

Copyright (c) 1998-2003 Brigham Young University. All rights reserved.
Reproduction in whole or in part in any form or medium without express permission of Brigham Young University is prohibited.

Documentation Revision: $Date: 2003/04/24 14:15:10 $ + When to assign a different parent to a wire? + Need a section on just how to read our documentation. + Is the asynchronous reset/set description in the Logic document correct?