PROCESSOR statement

processor statement  = "PROCESSOR", new identifier,

                       type specification, processor attributes;

processor attributes = "{" {processor attribute} "}"   |

                       {processor attribute};

type specification   = ["TYPE", "="], processor type;

processor attribute  = "ROOT"                          |

                       "BOARD",    "=", constant       |

                       "DEVICE",   "=", constant       |

                       "ATTACH",   "=", parent         |

                       "CLOCK",    "=", constant       | 

                       "CACHE",    "=", cache value    |

                       "KERNEL",   "=", kernel file    |

                       "LOAD",     "=", load file      |

                       "BOOT",     "=", boot file      |

                       "AVOID",    "=", avoid spec     |

                       "BUFFERS",  "=", constant       |

                       "UNCACHED", "=", cache range    |

                       "L1D",      "=", cache size     |

                       "P1D",      "=", cache size;

processor type       = CPU processor type |

                       FPGA processor type;

parent               = identifier;

CPU processor type   = identifier;

FPGA processor type  = identifier;

cache value          = "ON" | "OFF" | constant;

cache range          = cache address |

                       cache address, ":", cache address;

cache address        = constant;

kernel file          = string constant;

load file            = string constant;

boot file            = string constant;

physical area        = identifier;

avoid spec           = avoid address, ":", avoid size;

avoid address        = constant;

avoid size           = constant;

cache size           = constant;

The PROCESSOR statement declares a physical processor. If we need to refer to a processor later in the file, it must be declared with a processor statement first. Note that you need one processor statement for each processor in the system, even if the processors are physically clustered together in some way. The PROCESSOR (and WIRE) statements must correspond to the real hardware network on which the application will run. If this is not so, the application will probably fail to load.

The order in which you declare processors is significant as it is used to determine which processors need to be grouped together when they can be attached to an FPGA. This is discussed under ATTACH attribute.

The DEVICE attribute must be present and selects which device on a SignalMaster board of the declared type you mean. The following diagram shows the device values you should use for the different types of processor on SignalMaster boards.

The BOARD attribute selects a particular SignalMaster board; BOARD=0 is assumed if you omit this attribute. The BOARD values must be consecutive integers from 0 upwards, although you do not have to declare processors in the order of their BOARD attributes. The restriction is that, for example, if you have a processor with BOARD=3, you must also have processors with BOARD=2, BOARD=1, and BOARD=0.

The Lyrtech host software identifies boards by an index value. There is one range from 0 upwards for SignalMaster Quad boards and another separate range from 0 upwards for SignalMaster Dual boards. The index value corresponds to the position of the board in your hardware rack; boards in lower rack slot numbers have lower index values.

Diamond determines the index value to use to select a particular SignalMaster board as follows. First it scans through all the BOARD attributes in your configuration in order, starting at BOARD=0, looking for SignalMaster Quad boards. Each time it finds one it allocates it the next index value, starting from 0. The first Quad board is given index value 0, the next 1, and so on. The process is repeated for SignalMaster Dual boards, with the first Dual board being given index value 0, the next 1, and so on.

For example, assume you have these six boards declared:

PROCESSOR A  SMQ_DSP  BOARD=0 DEVICE=1

PROCESSOR B  SMD_DSP  BOARD=1 DEVICE=1

PROCESSOR C  SMQ_DSP  BOARD=2 DEVICE=1

PROCESSOR D  SMD_DSP  BOARD=3 DEVICE=1

PROCESSOR E  SMD_DSP  BOARD=4 DEVICE=1

PROCESSOR F  SMQ_DSP  BOARD=5 DEVICE=1

Assuming your hardware rack has six boards in the slot numbers given below, Diamond will match processors with physical boards as follows:

It achieves this result by allocating processor A to the first Quad board, B to the first Dual, C to the second Quad, and so on.