Machine Problem 5

Software/Hardware Design

Assigned	Monday, November 5, 2001
Due Date	Tuesday, November 13, 2001, 4pm
Purpose:	Hardware/Software Co-design to regulate network traffic flows
Points	50

Introduction

The FPX provides many useful features and funtions in hardware. One aspect of the FPX that has not been explored is communicating with it from software. The NCHARGE suite of tools allows users to issue control cells to perform various functions on the FPX. The control software is able to program the RAD, read and write memory, reconfigure the NID, as well as issuing custom control cells developed for the RAD.

NCHARGE provides many predefined control cells for a user to modify various aspects of the FPX. These functions are useful for the basic operations of the FPX. Once a user begins to develope their own custom hardware a need arises to communicate with this custom hardware through softare. NCHARGE allows users to develope custom control cells with predefined fields that enable communication with the hardware.

Description of the Assignment

The purpose of this assignment is to build a software plugin module that will commnicate with a modified FIFO circuit to update the pacing rate of the circuit, modify the FIFO length, and read the status of the MP5 module.

Control Cell Format

Shown below is the layout of a control cell issued by NCHARGE to the FPX. When creating a custom control cell the end user has control over what data is stored in the payload and where it is stored.

Developing a Custom Control Cell Module

The format of creating a custom control cell is based on an XML style interface where the user identifies relevant fields and where to place the particular information. Performing a particular operation in hardware is based on an opcode. Each unique operation has an opcode as well as relevant fields in the payload to read or write. In ARL we use the FPX to perform Fast IP Lookups (FIPL), a NCHARGE software plugin give us the ability to change certain aspects of the FIPL module while it is running in hardware. Below is the FIPL software plugin. This will be a useful template when developing your module in MP5.

<module> Fast IP Lookup Example Module 1.0 </module> <input_opcodes> 0x14, R,1,Root_Node_Pointer, 0x16, I,1,IP_Flow_1, 0x18, F,1,IP_Flow_2, 0x1A, B,2,IP_Flow_1,IP_Flow_2, 0x1C, C,1,Control_Cell_VCI, </input_opcodes> <output_opcodes> 0x15, 1, Root node pointer Updated to ,Root_Node_Pointer, 0x17, 1, IP Flow 1 updated to ,IP_Flow_1, 0x19, 1, IP Flow 2 updated to ,IP_Flow_2, 0x1B, 2, IP Flows 1 and 2 updated to ,IP_Flow_1,IP_Flow_2, 0x1D, 1, New Control Cell VCI is ,Control_Cell_VCI, </output_opcodes> <fields> Root_Node_Pointer,x,1,31,1,13, IP_Flow_1,x,2,31,2,16, IP_Flow_2,x,2,15,2,0, Control_Cell_VCI,x,3,31,3,16, </fields> <help> R root pointer address update: R address (hex) I Update IP Flow 1: I address (hex) F Update IP Flow 2: F address (hex) B Update IP Flows 1 and 2: b address1 address2 (hex) C Update Control Cell VCI: C VCI (hex) </help>

In the example above you can see the output opcodes are the responses to the input opcodes. Also declared in the software plugin are the module name, field declaration, and the help section. Below is the resultant control cell after loading the FIPL plugin.

Components of a Software Plugin

Module : Contains module name and version of software

Input Opcodes : Declares each input opcode sent to the FPX. The syntax here is the opcode in hex, the 1 Letter Variable representing that operation, the number of fields in this update, and the local variable to identify this fields dimensions.

Output Opcodes : Declares each output opcode received by the FPX. The syntax here is the opcode in hex, the number of fields in this update, the output string once the cell is received, and the local variable to identify this fields dimensions

Fields : Specifies the location of each field in the control cell. The syntax here is the local variable name,the type of data, (x=hex), and then start word, start bit, last word, last bit

Help : Used in the command line mode, specifies syntax on the loaded modules, not necessary for the web implemntation.

Issuing a Custom Control Cell

In order to use the software plugin, the user must first load the plugin into the NCHARGE software. When loading the module from the webpage you must specify a module number as well. This is used to identify the plugin from other software modules. Once it is loaded correctly you can issue commands from the web page or the console. For this assignment we will be using the web interface. You will need to generate a seperate control cell for each of the input opcodes. In each case you fill in the appropriate values for a cell and execute the command. Once issuing the command NCHARGE will display the control cell sent to the FPX. This is the cell you want to copy and paste into your simulation to update the pacing rate or fifo length.

Modification in the CellFIFO circuit

For this machine problem you have to modify the CellFIFO circuit you developed in the MP4. The requirement of the new circuit is that it should be able to change the size of the FIFO and the pacing rate dynamically. Hence, instead of reading the constants c_MaxFifoSize and c_PacingInterval from the PkgPacer.vhd, you need to implement internal registers to store the value of MaxFifoSize and PacingInterval. These values can be modified through some control cells you send to the hardware. Thus, you also need to insert a circuit in the CellFifo which will parse these special control cells, extract the opcodes and perform the required task. Although the CellFifo circuit extracts the PacingValue from the control cell, it does not use it. It is used by the out side statemachine PullCell to pull the cell from the FIFO at the regular interval specified by the PacingValue. Hence the PacingValue needs to be communicated to the outside statemachine by adding an extra port to the CellFifo called 'PacingValue' which is a 32 bit vector. You will also need to have an extra one bit signal 'ChangePacing' which gives a pulse when the PacingValue changes. The CellFifo entity is shown in the following figure.

Modified CellFIFO

Note that the modified PullCell statemachine has already provided to you. Some precautions:

1. The cells which come into the CellFifo are in 64 bits words, and not 32 bit word. The first 32bit word maps to 63 downto 32 and the next 32bit word maps to 31 downto 0. This should be considered when the cells are being parsed.
2. The size of the FIFO should be changed only when the FIFO is empty, otherwise it results in erratic behavior.
3. When the new PacingValue is put on the 'PacingValue' port, the ChangePacing should go high and then go low in the next cycle immediately. In other words ChangePacing is a pulse.

Assignment Details

Download the tar file here and untar it
Complete the custom control cell shown below. Pay attention to special syntax rules, (commas at the end of lines) to ensure NCHARGE loads the module properly.

<module> -- Your Name and module number here -- </module> <input_opcodes> 0x10, S,0, 0x12, P,1,Cell_Pacing, 0x14, M,1,Fifo_Length, 0x16, B,2,Cell_Pacing,Fifo_Length, </input_opcodes> <output_opcodes> 0x11, -- your definition here -- 0x13, -- your definition here -- 0x15, 1, Fifo Length updated to ,Fifo_Length, 0x17, -- your definition here -- </output_opcodes> <fields> Current_Length,x,1,31,1,0, Cell_Pacing, -- your definition here -- Fifo_Length, -- your definition here -- </fields> <help> Optional Help Field -- Not used in web interface </help>

Upload your custom control cell module to NCHARGE via the web interface
Load your module into NCHARGE on your specified module ID
Execute your module specific commands on NCHARGE
Copy and Paste Control Cell Results into the testcell.dat along with relevant data cells as outlined in the lecture 13 notes
Develop VHDL code for the modified CellFifo circuit
Create the testbench described in lecture 13 notes and generate the appropriate waveforms

Things to turn in

Mp5 Software Plugin for NCHARGE
VHDL code for modified "CellFIFO.vhd"
Testcell.dat testbench file
Waveforms of the simulation demonstrating all the points mentioned above

Please print the grade sheet and staple it on top of your machine problem.