Home FAQs
From the list below choose one of our FAQs topics, then select an FAQ to read. If you have a question which is not in this section, please contact us.

Does Diamond support processor farms?

E-mail Print PDF

From V4.1.0 you can use Diamond Premium to create processor farms.

 

A processor farm is built from two tasks that you write: a MASTER task and a WORKER task.

The master task has two threads: one breaks your problem into smaller sub-problems and sends work-packets describing each sub-problem into the farm; the other receives responses from the farm and combines them into the desired solution. For example, an application to perfrom ray tracing could break the scene into a number of lines and send the coordinates of each line into the farm as work packets. The responses would be bit-maps for the rendered lines.

A worker task is an infinite loop that repeatedly reads a work packet, processes it, and then sends a response packet before going round to read another work packet.

All communication in these tasks is performed by two functions: farm_in and farm_out. That is all you need to know about farm communication!

 

You tell the Diamond configurer about all the processors you want to use in your farm and where to place the master task and copies of the worker. The configurer will automatically construct an application that will load all your tasks along with extra routing tasks that move packets efficiently around your farm. These routing tasks perform simple load balancing to ensure that workers are kept as busy as possible.

 

Here is an example of a configuration file to construct a simple farm on a twelve-core EVP6472 module. The master task is placed on cpu_0 and a copy of the worker task is placed on every declared processor:

processor cpu_0   EVP6472 root
processor cpu_1   EVP6472
processor cpu_2   EVP6472
processor cpu_3   EVP6472
processor cpu_4   EVP6472
processor cpu_5   EVP6472
processor cpu_6   EVP6472
processor cpu_7   EVP6472
processor cpu_8   EVP6472
processor cpu_9   EVP6472
processor cpu_10  EVP6472
processor cpu_11  EVP6472

task Master data=30K ins=1 outs=1
task Worker data=30K

farm {


MASTER Master cpu_0
WORKER Worker *


}

 

Are Diamond communications polled?

E-mail Print PDF

In a word, no. Diamond never uses polling for I/O transfers. Whenever a thread has to wait for a channel transfer, it is descheduled and other threads continue to execute. The waiting thread will resume when the completion of the transfer is signalled by an interrupt.

The mistaken idea that Diamond polls probably derives from an incorrect statement in a 2006 article by M. Raulet et al, Rapid Prototyping for Heterogeneous Multicomponent Systems: An MPEG-4 Stream over a UMTS Communication Link (EURASIP Journal on Applied Signal Processing Volume 2006, Article ID 64369, 1-13, DOI 10.1155/ASP/2006/64369).

This article stated that '[in 3L Diamond,] data transfers are realized using DMA, but without any computation parallelism which is nearly equivalent to polling technique.' This is simply a misunderstanding of how Diamond works. A thread that is waiting for a channel transfer is indeed blocked and performs no more computation until the transfer has completed, but other threads continue to run, providing the 'computation parallelism' that is claimed to be absent. There is no polling (or its equivalent) in Diamond communications.

 

Why do I need 3L Diamond?

E-mail Print PDF

This is rather like asking, why do I need a high-level language? The strict answer is that you can make do without tools to help you build applications, but you will be making your task an order of magnitude harder.  If you decide not to use 3L Diamond to build a multiprocessor application you will have to do all the work yourself, including things like:

  • loading all the processors, including ones remote from the host PC
  • keeping control of all the separate modules needed to load your application
  • starting your application in a synchronised way
  • managing communications, possibly including deadlock-free message routing
  • writing your own device drivers
  • explicitly managing all memory allocation
  • writing your own multithreading support or using something that is likely to be less efficient than Diamond's
  • inventing a host communication mechanism
  • being prepared to rewrite your source if the configuration changes
  • being prepared to make major changes if the underlying hardware changes
  • supporting multiple source versions for all hardware and configuration variations
  • handling all of the underlying hardware peculiarities (unexpected cache behaviour, for example)
  • ... and many more.

Diamond can do all of this for you. 3L works closely with hardware vendors and puts a great deal of time, effort, and experience into optimising all aspects of the system to give you the best results.

See the more complete article here.

 

 

What makes 3L Diamond different?

E-mail Print PDF
There are many features that make Diamond significantly different from other tools that developers try to use for multiprocessor applications. Some of the more significant features are:
  • Diamond was designed from the beginning for highly-optimised multiprocessor applications and has been used successfully on platforms with from one to over one thousand processors. It is not a single-processor system that makes claims to support multiprocessors or one that has been stretched to try to do things that far exceed its original constraints.

  • Diamond has a coherent model that is used to describe multiprocessor systems and transparently supports heterogeneous systems made from differing processor types. It is not an ad hoc collection of bits and pieces that you have to fit together as best you can.

  • The Diamond model works equally well on DSPs and FPGAs. Even users with little or no knowledge of FPGAs can use the impressive parallel performance they offer to accelerate parts of their applications.

  • The Diamond multiprocessor compiler is unique. It constructs your application after having been presented with all of the required components and so can gather information from them to detect many opportunities for in-processor and system-wide optimisations.

  • Diamond loads the whole of the processor network for you; you do not have to struggle loading each processor individually.

  • Diamond's flexibility is unsurpassed. You can easily change your hardware, the number and type of the processors, and the topology of your system without needing to change your code. Building variant applications with tasks moved from one processor to another, even from DSPs to FPGAs, is truly trivial.

  • Diamond takes over many of the boring and error-prone housekeeping operations that are of little real interest to you but essential to get a multiprocessor application working. That leaves you free to concentrate on your core skills and algorithms.

 

Do I need other software? Which versions in particular?

E-mail Print PDF

Diamond allows you to build tasks for DSPs and FPGAs.  The source code for these tasks is translated by tools which you need to have installed.  These tools include compilers for DSPs and GPPs, and bitstream generators for FPGAs. Commonly these will be the TI compiler, linker and assembler which you get as part of Code Composer Studio, and the Xilinx ISE tools.  These tools must be obtained separately.

Diamond supports these software tool versions:

Diamond Release Supported CCS version Supported Xilinx ISE Foundation version
3.1.10 3.3 9.2
3.2.2 3.3 11.4
4.0 4.0 11.4 onward

There are some optional tools that you can get from third parties to assist building Diamond tasks, for example Impulse Co-Developer; these can increase productivity but are not essential.

 
  • «
  •  Start 
  •  Prev 
  •  1 
  •  2 
  •  3 
  •  Next 
  •  End 
  • »
Page 1 of 3

Try Diamond Now!

DemoSystem1

Did You Know?

You can use an FPGA task to create a clock domain.