Challenges of Designing with Multiple Processors

What comes to mind when you hear distributed system? Sharing processing tasks with a computer grid? Ecommerce systems processing global orders? Wireless sensor networks monitoring the status of a building? All of these examples share a fundamental theme—distributed systems using multiple processors to solve a problem. Because of the reduced cost and tremendous performance improvements in semiconductor technology, engineers and scientists are finding effective ways to meet application challenges by adding more processors and more intelligence to their systems.



Essentially because of the reduced cost and tremendous performance improvements in semiconductor technology, engineers are finding effective ways to meet application challenges by adding more processors and more intelligence to their systems. As a result, the products that are designed, as well as the systems developed for testing and controlling these products, are becoming more distributed.





Designing multiple computing engines into a test or control system is challenging. Engineers have to develop algorithms in higher level tools that then have to be translated into fixed point implementations to run on microcontrollers. Distributed system development brings to light an entirely new set of programming challenges that traditional tools do not properly address. National Instruments LabVIEW 8 introduces distributed intelligence technology to address these challenges with the:



• Ability to program multiple targets such as desktop, industrial, mobile, and embedded devices.



• New LabVIEW Project to provide an intuitive system view for navigating and managing distributed systems from a single environment.



• New communication interface, called the LabVIEW shared variable, to simplify data communication among distributed devices and systems.



• Tools for timing and synchronizing within and between distributed devices and systems.



One can find distributed applications in various industries and different product life-cycle phases, but these applications involve similar challenges, such as:



• Programming applications that take advantage of multiple processors based on the same or mixed architectures such as microprocessors, FPGAs, or DSPs.



• Efficiently sharing data among multiple processors that are either directly connected on a single PCB, within a single chassis, or remotely connected on a network.



• Coordinating all nodes as a single system, including the timing and synchronization among nodes.







• Integrating different types of I/O such as high-speed digital, analog, motion, and vision.



• Incorporating additional services to the data shared among nodes, such as logging, alarming, and integration with enterprise systems.





Programming Distributed, Heterogeneous Computing Nodes

Distributed systems often include nodes such as sensors, devices, or systems, which perform different functions. Additionally, all of these nodes might communicate to a host supervisory system that logs data. Today, architects of distributed systems use different tools to program each node. Furthermore, the system may have advanced requirements that cannot be met with off-the-shelf hardware, requiring configurable hardware such as FPGAs to execute complex mathematical algorithms. Learning and using different tools for programming FPGAs, real-time systems, and desktop systems leads to longer, more complex development timelines for engineers.



LabVIEW 8 addresses this programming challenge by providing the tools to program dissimilar nodes from a single development environment. One can use LabVIEW 8 develop code to run on computing devices including desktop PCs, real-time-based devices, and FPGA-based measurement and control systems. In addition, LabVIEW includes, in a single platform, the specialized functions for image pattern matching for automated inspection, trajectory generation for motion control, and measurement and digital logic for environmental control, which often requires expertise in separate custom applications.





Communication and Data Transfer

Distributed applications require various forms of communication and data sharing. Communicating between processors, particularly real-time and embedded systems, without impacting performance can be a challenge. While various standards and protocols exist for communication—such as TCP/IP, UDP, Modbus, and OPC—one protocol usually cannot meet all of your needs, and each protocol has a different API. This forces system integrators to use multiple communication protocols to complete the entire system. Deterministic data transfer among nodes, often entail using expensive solutions based on technologies such as reflective memory. One way to address these competing needs is to abstract the specific transport layer and protocol from the development API. By doing this, you can use multiple protocols under the hood, dramatically saving development time.











LabVIEW 8 with distributed intelligence addresses these challenges with one flexible, open communication interface that provides data sharing among different processors and real-time controller nodes as well as integrates third-party devices. The new LabVIEW 8 shared variables, an abstraction layer for protocol transport, can handle complex data types required for advanced distributed applications and can scale to include high-level functions such as logging and alarming. These shared variables can be used to share data to and from any node in the system, including real-time nodes, historical databases, and Web-based supervisory consoles.





Navigate, Debug, and Deploy Code to Distributed Nodes

Moving data and commands among different computing nodes in a distributed system is only one of the challenges involved in developing a distributed system. Managing and deploying the source code that runs on these distributed nodes is a fundamental challenge system developers face. In the simplest distributed case, where homogenous computing nodes execute the same source code, you can maintain the master source in one place and then distribute it to all nodes when the code changes. In the advanced distributed case, each node has dissimilar executable code running on mixed architectures, and all nodes may not be online simultaneously. Using LabVIEW the source code and settings for all nodes in a distributed system can be stored.





Synchronizing the System Across Multiple Processors and Targets

An important component of many distributed systems is coordination and synchronization across intelligent nodes of a network. Oftentimes, engineers use built-in hardware approaches for routing timing and synchronization signals through FPGA devices and integrated backplanes.



LabVIEW 8 introduces a new deterministic Ethernet solution for reliable synchronization among distributed systems. The new, time triggered LabVIEW shared variable addresses advanced distributed applications including distributed control and correlated data acquisition across networks. Instead of expensive reflective memory card solutions, LabVIEW 8 provides an easy, cost-effective, off-the-shelf solution to achieve network cycle rates of 100 μs with ±5 μs clock synchronization

between nodes.



Test and control systems are evolving into distributed systems with tightly integrated computing power. LabVIEW 8 delivers a powerful framework for you to easily design, manage, deploy, and synchronize distributed systems. To meet your distributed development challenges today and in the future, the LabVIEW platform:



• Targets multiple architectures, including desktop, industrial, mobile, and embedded devices such as MPUs, DSPs, and FPGAs.



• Introduces the LabVIEW Project, an intuitive system view for navigating and managing distributed devices from a single environment.



• Simplifies data communication among different computing engines with the new LabVIEW 8 shared variable.



• Supports numerous approaches for timing and synchronizing systems, including a new, deterministic Ethernet technology for network synchronization.