Vectors in Nanosim:

This page describes how to stimulate a nanosim simulation with vectors, and how to have nanosim check if the output matches other vectors at specified times.

This example refers to several files in this directory.

• One has to start with a circuit, either in a schematic editor (e.g. sue) or in layout (e.g. magic), and extract it into a spice netlist. The netlist must have a .spi (not .spice) extension. In this example, I use count32.spi, a 32-bit ripple counter spice netlist extracted from SUE.
• Next one has to set up various things in nanosim. First, I use a spice deck, count32.sp. Most of the lines in this file should be obvious. Here are a few that are important and/or less intuitive:
  • Use the nanosim transistor model in the TT corner (typical N and P transistor doping):

       .lib 'logic025.ns' TT

  • Use the spice netlist for counter32:

       .inc 'count32.spi'

  • Run the simulation for 100 clock cycles with 10 picosecond precision:

       .tran 10p '100*ct'

• One also set up various things in in a .cfg file. I use count32.cfg. A few of important lines are:
  • Set the simulation accuracy (1-5). Level 5 is similar to a spice simulation and takes about as long. Level 1 is like an IRSIM simulation and is similarily short in execution time.

       set_sim_level 4

  • Tell nanosim which nodes to print in the .out file. For a reason that I don't understand, you have to use print_node_logic for nodes with vector input stimulous; otherwise these nodes are only reported at the times in the input vector file and the waveform view linearly interpolated in between. E.g.:

       print_node_logic   rst
       print_node_voltage q[0]
    

• The command file, count32.cmd, is the file that tells nanosim the name of the vector files and the names of the vectors:

     (is=vec) (en=count32.vec)    (ot=in,rst,q[3],q[2],q[1],q[0]);
     (is=vec) (en=count32_2.vec)  (ot=q[3-0]);
  

  Note that one can use multiple vector files.
• The run file, count32.run, is just an executable one-liner that runs nanosim:

     nice -n 5 nanosim -n count32.sp count32.cmd -c count32.cfg -o count32

  The first part, 'nice -n 5', just runs the job at lower priority and can be omitted. Nanosim will run and generate a lot of chatter to the standard output (and also in count32.log)
• The vector file, count32.vec, is referenced in the run file (see above), and tells nanosim what the expect output should be at specified time steps. It looks like this:

     radix       11 4 1111
     io          ii o oooo
     ;           cr q qqqq
     ;           le 3 3210
     ;           os - 
     ;           ce 0 
     ;           kt  
     ;   
               0 00 x xxxx ;comment
               5 10 x xxxx
              10 01 x xxxx
              15 11 x xxxx
              20 01 x xxxx
              25 00 0 0000
              30 10 0 0000
              35 00 1 0001
              40 10 1 0001
              45 00 2 0010
              50 10 2 0010
              55 00 3 0011
              60 10 3 0011
              65 00 4 0100
              70 10 4 0100
              75 00 5 0101
              80 10 5 0101
              85 00 5 0101
  

  The syntax should be obvious. Note that the nodes names run vertically and ";" denotes the beginning of a comment. At the time given in the left most column group, nanosim asserts in the inputs (denoted by "i" in the io line) checks the outputs (denoted by "o" in the io line; "x" = don't care). Values in the radix line set the node types (1 = binary, 4 = hex, etc.)
• When the simulation is complete, nanosim reports any discrepencies between it's output and the expected vector output in the error file, count32.err. I intentionally put one error in the above example. At 80ns clock toggles high and at the next timestep the counter does not increment. Nanosim says that the value of q[3:0] should be 0110 and the vector file says that it should be 0101. This is reported as two errors, one each for q[1] and q[2]. The relevent lines in the error file are:

     85.00 1 1 1 0 q[1]
     85.00 1 1 0 1 q[0]