Microprocessors and DSPs

Nice Info on Processors and DSPs.
----------------------------------------------------
Multi-core processor design needs graphical approach
by Ian Bell, National Instruments Friday 18 May 2007

Multi-core processors are now a reality which embedded system developers must face. Many embedded developers are beginning to realise the shortcomings of traditional development approaches when faced with multi-core architectures.

A key step in tackling a multi-core design is developing a clear software design methodology. Two critical components of this methodology are the software tool flow and the real-time operating system.

Software tool flow, starting with algorithm development, continuing through software prototype, and on to final deployment, is a critical component due to the programming complexity involved in a multi-core design.

In addition to the thread-handling and priority-scheduling that a real-time operating system (RTOS) delivers on any platform, the RTOS also manages the hardware abstraction layer.When dealing with embedded systems, it is no secret that the lines of code quickly increase, as the overall complexity of the application escalates.

The introduction of multi-core processors adds yet further to programming overhead.A method to abstract the complexity of programming embedded systems - both in single processor and multi-core designs - is to choose a software tool flow based on a graphical approach.The advantage of this methodology is that many graphical-based tools include native functionality to handle complex programming and timing. This means the embedded developer can focus on the critical pieces of code, such as the application itself, rather than the low-level details.For an example of how a graphical approach can abstract programming complexity, see the diagram (right).

This LabVIEW application uses two loop structures which contain a filter task and an FFT task running in parallel. Using LabVIEW loops in this manner divides an application into independent threads, with user-defined priorities and execution rates.

In a multi-core design, these threads are handed-off from LabVIEW to the OS, which takes care of the load balancing between multiple processors.Graphical system design is an approach that takes advantage of graphical programming in the context of embedded design. This approach consists of three main stages: design; prototype; and deploy. DesignThe first stage is to design the primary IP of the application in the form of algorithms and functionality used to describe the system.

There are various high-level views to design the IP. For example, an engineer could describe control tasks using a model-based view, digital signal processing tasks using data flow, and mathematical formulae textually. NI LabVIEW accommodates these different views by including text-based math, continuous time simulation, state diagrams and graphical dataflow models all within the same development environment.

Prototype, The next stage in the graphical system design process is to prototype. In this case, the term prototype does not refer to an early iteration of the final custom embedded design. Rather, this stage refers to a functional, yet experimental prototype. The process consists of taking the code created in the design stage, and verifying that design in a real-world environment using commercial-off-the-shelf (COTS) processors and I/O modules.

A developer who designs a VI that has multiple simultaneous execution paths can instantly see increased computing power and shorter data processing times, without the need for any special coding or design techniques.

The combination of graphical programming with the right RTOS ensures that developers can immediately scale their projects from single CPU targets to multi-core targets without any design changes.