The way you now create attached processors is to declare the one at the top of the hierarchy and then declare deeper processors as being attached to one above.
PROCESSOR X TYPE=some_FPGA
PROCESSOR A TYPE=some_DSP ATTACH=X
PROCESSOR B TYPE=some_DSP ATTACH=X
This is the opposite of the way things were done in previous versions.
One immediate benefit of doing things in this order is that it becomes easy to increase the depth of the hierarchy. So, in the example above, if the FPGA X is itself attached to another FPGA, W, we can describe the system as follows:
PROCESSOR W TYPE=some_other_FPGA
PROCESSOR X TYPE=some_FPGA ATTACH=W
PROCESSOR A TYPE=some_DSP ATTACH=X
PROCESSOR B TYPE=some_DSP ATTACH=X
Diamond allows a simplification in the case when you do not need to change the default behaviour of the FPGA to which other processors are attached; you can omit the declaration of the FPGA and leave the other processors unattached. You would rewrite the first example above as follows:
PROCESSOR A TYPE=some_DSP
PROCESSOR B TYPE=some_DSP
The definition of the processor type (some_DSP) informs the configurer that these processors need to be attached to an FPGA. The configurer automatically and invisibly declares a suitable implicit FPGA processor for you and attaches your processors to it. Because of this, existing applications that do not use FPGAs can be left unchanged.
The processor type of each FPGA defines how many processors can be attached. Each time you declare an unattached processor, it will automatically be attached to a previously-declared implicit FPGA of the corresponding type until that FPGA is 'full'. Subsequent unattached processor declarations will lead to additional invisible FPGAs being declared for you.
Note that a processor will never be attached automatically to a processor that you haven't declared explicitly.
Consider the following example, where two processors of type some_DSP can be attached to an FPGA of type some_FPGA:
PROCESSOR P1 TYPE=some_DSP
PROCESSOR P2 TYPE=some_DSP
PROCESSOR P3 TYPE=some_DSP
This is structurally equivalent to declaring the processors as follows:
PROCESSOR F1 TYPE=some_FPGA
PROCESSOR P1 TYPE=some_DSP ATTACH=F1 ! first DSP on F1
PROCESSOR P2 TYPE=some_DSP ATTACH=F2 ! second DSP on F1
PROCESSOR F2 TYPE=some_FPGA
PROCESSOR P3 TYPE=some_DSP ATTACH=F3 ! first DSP on F2
The only significant difference between these two configurations is that in the first, where the FPGAs are implicit, the configurer does not attempt to create new firmware; when the FPGAs are declared explicitly the configurer is allowed to generate new firmware when required (note that this can succeed only if you have a suitable Diamond FPGA licence).
Attaching processors is done in the IDE as follows:
When you create a processor, the IDE gives you the option to attach it to an existing processor of the appropriate type. In the example below, you have created a root processor which is an FPGA. Now when you create a node processor of the matching type, the 'Attaches to' box shows that you can attach it to root. You do this by clicking root in this box to select it before clicking Finish to create node. If you do not select a processor for the new one to be attached to, any attachment to implicit processors is done automatically as described above.
You can always add or change the attachment later by going to the Advanced section for the processor and looking under Attachment.
You can find more information about attaching processors under ATTACH attribute.