IBM Software Rational Thought Leadership White Paper Building smart products: best practices for multicore software development
2 Building smart products: best practices for multicore software development The planet is becoming more interconnected, instrumented and intelligent. All kinds of devices from medical devices to the global positioning system (GPS) in your car to large-scale defense systems rely on embedded software to interact with other systems and deliver an exceptional, differentiated user experience. But as the marketplace increasingly demands embedded systems that deliver greater functionality, a smaller form factor, greater reliability, lower power and a lower cost of operation, the pressure on companies to deliver just the right products increases. To make matters worse, companies are facing increasing time-to-market pressures, renewed calls for greater safety and security, limited development resources, and a need to lower costs. Multicore technologies have arisen to help address these competing concerns. Multicore enables companies to achieve significant power savings while increasing performance and scalability to support ever-escalating software demands. It also allows physical separation of software to help ensure that security and safety-critical concerns are met. And multicore provides a lower price-to-performance profile, driving significant product savings. Critical concerns in the move to multicore Moving to multicore-based products isn t always easy. Before you make the switch, it s important to consider the types of applications you ll be developing, the architecture of your hardware and software, your product goals, and your performance goals. There are many decisions to make when developing a multicore-based product, so it s essential to consider what processes you will use to assess alternate designs. You also need to look at your existing processes for change management and quality management and assess whether they will be appropriate for multicore. Your existing platform is another consideration. Will it be optimized for multicore? And is it scalable over the life span of your devices? These are important questions to ask. Finally, consider your existing software assets. Will they be reusable? And are they optimized for multicore? Giving serious consideration to each of these issues before moving to multicore can help make your transition more successful. Best practices from IBM and Wind River for multicore development Software is the key to success with multicore-based products. An integrated approach to building software that combines the design, development, test and platform configuration will enable you to capitalize on multicore s significant power and cost savings, substantial improvement in scalability, and feature support. IBM and Wind River have teamed to identify and enable the following best practices that can help smooth the transition to multicore development. Assess alternatives early Use automated generation Leverage existing software Best practices for multicore development Exploit an optimized multicore platform Apply virtualization Continually debug and test Figure 1: IBM and Wind River best practices can help make the transition to multicore easier.
IBM Software 3 Use trade-off studies to assess your alternatives as early in the process as possible Software must be the driving force behind your design decisions. It will ultimately determine your operating system needs and how well your system performs. Simply taking software from an existing system and moving it to a multicore processor will likely result in its running at the same speed or potentially even slower. That s why you need to consider the distribution of your software functionality, your resource needs and your performance goals as you begin to plan your project. Performing trade-off studies is critical to assessing alternatives and ensuring that you actually realize the desired improvements in performance, speed and resource utilization. Modeling the software architecture and different designs before committing to code can help you make better decisions and help improve the quality of your finished product. Modeling enables you to map existing tasks to cores and add other tasks as needed. Further, modeling can help you gain an understanding of how to optimize communications between the tasks and processes making up your system software. Finally, alternative operating system configurations may yield significantly different results, so they must be considered as part of the overall trade-off assessment. Simulation can also help you ascertain whether the solution will perform as expected or whether alternative designs might produce better functional results. Distributing functionality across a truly parallel environment can cause unforeseen task interaction, which may affect the quality of the delivered system. So simulation can help you determine where problems with interaction might occur and help ensure that the design will work as desired. From host-based to board-level environments, the right simulation tooling can help teams determine whether the software being developed will perform as expected before the hardware is available or even fully specified. Leveraging simulation at every level as part of an iterative and agile process can reduce risk in the software development life cycle. The modeled architecture and behavior of the software created as you perform the trade-off studies captures these important decisions and helps communicate them to stakeholders. You can document the trade-offs and make more-informed decisions about the product design along with the resources that will be required to implement it. This process helps ensure that the move to multicore is successful and that the product requirements, including performance and feature content, are addressed. Leverage existing software assets Reuse has become a fundamental part of good software development practices. It simply doesn t make financial or logistical sense to start each and every project from scratch even when you re moving to a new development model. To reduce costs and improve efficiency, you need to find ways to take advantage of existing code and existing products. However, transitioning existing software to multicore may uncover defects and unexpected behavior even if the software ran well in a single-core environment. Modeling and a model-driven approach to analyzing existing software can help your teams make this transition easier by helping them understand the current architecture of existing software and its underlying relationships.
4 Building smart products: best practices for multicore software development Visualization yields a deeper understanding of your existing assets and enables you to document your existing designs. You can then import, repartition and refactor existing software to optimize it for a multicore environment, at which point it can be integrated into new design components and the new application architecture. Modeling and automated code generation help make refactoring existing code a cost-effective alternative to rewriting the application from scratch. Finally, existing software components can be used in new designs and applications that are built for the products that target a multicore environment. Again, visualization, refactoring and automated generation capabilities in a strong modeldriven development tool greatly enhance your ability to make these reuse decisions. Further, when the components being reused have a track record of success in earlier products, their behavioral aspects are understood and tested, limiting the new test-and-debug efforts required for the new application. Clearly the ability to visualize existing designs, refactor them for multicore optimization, and integrate the software into new designs and architectures is critical to help ensure that the benefits of reuse to the business are achieved. Use automated generation of code, documentation and configurations Automation is another way to reduce costs, improve efficiency and ultimately speed time to market. The trade-offs you ve modeled can be leveraged through automation to quickly generate the structure, behavior and interprocess communications (IPC) code necessary to run the software on the specified multicore operating environment. The visualization of design and systematic replication of this design in the generated code is enabled through automatic generation and is critical to helping ensure that the delivered product addresses the expressed needs of the customer for functionality and performance. When moving a software component from one core to another, the modeled change can be regenerated and reflected in code that is specific to the new core as needed, even if it uses a different operating system or a different protocol to communicate with tasks on the original core. Typically, these moves would require developers to hand code the change, but with a modeled application, this change occurs simply by associating the task to the core. The automatic generation capabilities of a model-driven development tool handle the rest of the conversion to code and a running software component. Further, the optimized design can be generated into documentation that can support regulatory compliance or product certification efforts. In every phase of development for multicore, modeling, code generation and automated documentation are critical to helping companies deliver products with the right capabilities and the expected level of quality, on time. Continually debug and test It s no longer sufficient to worry about product quality after the software has been built particularly when you re dealing with embedded software that will be interacting with other components. Therefore, when using model-driven development techniques, it s important to continually test and debug. You need to test and debug at the model level as well as the code level on the host system and on the target system. Automated testing solutions can help you get more-effective test coverage and help you analyze runtime characteristics such as memory usage and performance.
IBM Software 5 A typical workflow might include the following steps: Use models first to validate the software architecture and design. This validation might include internal design reviews and walk-throughs. Models might be executable before they are fully realized, which means the architecture and behavior can be tested very early in the software development life cycle. These early execution tests may be derived automatically from the scenarios that elaborate the set of functional requirements for the software. Take advantage of target simulators and testing tools. During code development, developers can then leverage host-based and target simulators along with testing tools to perform early verification before integration and hardware availability. Changes to architecture can be made via models and subsequent code generation. Verifying models and generated code with hardware simulation results in realistic testing much earlier in the development process and makes it easier and more worthwhile to continually test models and code as they are modified. The same scenario-based tests used in the early execution phase can be leveraged to test the generated code as it is built, both on target simulators and in the host environment. Introduce test automation when code is available from developers. Testing can be done on either real hardware or simulators. By automating testing, teams can continually increase test coverage. Without automation, achieving adequate testing coverage is extremely time consuming and expensive. Dynamic runtime analytics can be used at this point to measure what is being tested in the real operating environment. Perform system integration and deploy real hardware. Leveraging on-chip debugging is a key tool at this stage to make debugging on real target hardware easier and more efficient. Multiple context debugging provided by Wind River Workbench On-Chip Debugging allows developers to debug potentially complex multicore scenarios that were difficult to debug in the past. Repeat these steps for updates. During product deployment, when making updates to system software as part of product maintenance, you can leverage the same modeling, coding, testing and deployment workflow described above. For many systems, software updates are required many years after initial deployment, so modeling and testing assets grow in value as time goes by. Apply virtualization It s clearly impossible to know what all of your future requirements will be. By adding a layer of virtualization to your applications, you can gain greater platform flexibility and make the right design choices based on your software not your platform. For example, it s possible to mix different operating systems on the same processor (multicore or single core), to host several instances of the same operating system in asymmetric multiprocessor (AMP) configurations, or to mix and match different operating systems and different multicore configurations, including AMP and symmetric multiprocessor (SMP) configurations. This flexibility can help future proof your multicore architecture because almost any possible configuration can be adopted in future revisions of your product. Virtualization also enables you to consolidate multiple applications and hardware configurations onto a single platform, potentially reducing hardware costs. For example, mixing a general purpose operating system (GPOS) and a real-time operating system (RTOS) can reduce the need for two or more separate systems in a previous generation product. Modern multicore platforms are providing sufficient computing power to enable this virtualized platform that further enables dramatic system consolidation on to a single device. Virtualization provides the flexibility that can help you future proof your product lines by enabling you to modify the target multicore configurations or add new platform requirements as your needs change.
6 Building smart products: best practices for multicore software development Leverage an optimized multicore platform To fully exploit the features of multicore, you need to make sure you re considering all of your architecture options. You need to take advantage of the operating system flexibility of multicore so you can support both RTOS and GPOS. You also need to choose the correct platform for your specific needs, either AMP or SMP. In AMP configurations, there is typically one operating system per core, and each core is independent of the others. Each OS can be different. With SMP configurations, one operating system controls all the cores, and the hardware complexity is abstracted from the applications running on it. Whatever multiprocessing mode is used, it s important that the operating system s platform is optimized for the underlying hardware architectures. This optimization process includes processor-specific tuning and leveraging acceleration coprocessors for networking, graphics or multimedia processing. In the case of an AMP configuration, it s important that the RTOS provide efficient IPC middleware for instances of the RTOS to communicate with each other. It s equally important to have an RTOS that is field proven in such configurations because of complexities such as handling interrupts. In an SMP configuration, it s important that the operating system be tuned to the particular processor because each has unique optimizations available. Equally important is the middleware that supports the RTOS because the network stack, graphics and file systems must be tuned to the particular multicore platform. In some cases, graphics and networking stacks should leverage additional hardware acceleration that the platform provides. Finally, it s essential to have support for virtualization, testing and modeling tools and on-chip debugging so you can take full advantage of multicore best practices. A comprehensive solution helps take the risk out of multicore development IBM Rational software a marketplace-leading platform for software life-cycle management is teaming with Wind River a global leader in the embedded and mobile industries to help companies take the risk out of multicore software development. The solution combines a set of preintegrated tools from IBM and Wind River that can help you manage multicore development from the early analysis and design phase all the way through testing on the target system. The solution includes: IBM Rational Rhapsody software, which supports modeldriven development including simulation and automated test generation. IBM Rational DOORS software for comprehensive requirements specification and management. IBM Rational Quality Manager software to manage quality aspects throughout the development process. IBM Rational Team Concert software for comprehensive change and configuration management. Wind River VxWorks and Wind River Linux software providing optimized multicore operating environments. Wind River Hypervisor for comprehensive virtualization support. Wind River Test Management to handle definition and tracking of testing on multicore environments. Wind River Workbench to manage the work environment for the development team, including code development and debug and test support. Wind River Simics, which supports board-level simulation.
IBM Software 7 IBM Rational Rhapsody software Model-driven development, simulation and testing WIND RIVER Wind River platform for multicore Wind River VxWorks and Wind River Linux Middleware Wind River Hypervisor IBM Rational DOORS software IBM Rational Requirements Composer software IBM Rational Team Concert software Collaboration IBM Rational ClearCase software IBM Rational ClearQuest software IBM Rational Build Forge software Requirements definition and management Build and release management Analysis and design Configuration and change management Construction WIND RIVER Wind River Workbench Development environment System and application monitoring On-chip debugging Wind River VxWorks and Wind River Linux Simulation Core file support IBM Rational Asset Manager software WIND RIVER Production WIND RIVER Quality management Asset management and reuse IBM Rational Quality Manager software Test planning and execution Reporting Wind River platform for multicore Wind River VxWorks and Wind River Linux Wind River Hypervisor Wind River Test Management Test execution optimization Test coverage and traceability Comprehensive run-time analytics Management of test labs and devices Not all Rational and Wind River products are shown. Figure 2: Rational software and Wind River provide solutions that can help you manage nearly every aspect of the multicore development and delivery process. Part of an integrated life-cycle approach to embedded software development IBM Rational software provides systems engineering and software development products, services and best practices to help companies define and manage their product development processes. The IBM Rational Software Delivery Platform for systems includes collaborative tools for requirements definition and management, model-driven development, software configuration and change management, build management, and test and quality management to help you manage just about every aspect of the software development life cycle. Wind River provides a wide range of operating systems and middleware that leverage the latest processor technology to address the needs of a broad range of companies. Wind River also provides the Wind River Workbench development platform including on-chip debugging, such as Joint Test Action Group (JTAG).
Together, Wind River and IBM can provide companies with the hardware-optimized runtime environments, middleware, software development tools and services they need to develop high-performance, maintainable and scalable multicore solutions. Together, Wind River and Rational solutions help developers architect and build devices for the future building products right the first time, reducing development costs and speeding time to market. For more information To learn more about how IBM and Wind River can help you successfully transition to multicore development, contact your IBM or Wind River representative or IBM Business Partner, or visit: ibm.com/software/rational/offerings/windriver/multicore Additionally, financing solutions from IBM Global Financing can enable effective cash management, protection from technology obsolescence, improved total cost of ownership and return on investment. Also, our Global Asset Recovery Services help address environmental concerns with new, more energy-efficient solutions. For more information on IBM Global Financing, visit: ibm.com/financing Copyright IBM Corporation 2010 IBM Corporation Software Group Route 100 Somers, NY 10589 U.S.A. Produced in the United States of America June 2010 All Rights Reserved IBM, the IBM logo, ibm.com, and Rational are trademarks of International Business Machines Corp., registered in many jurisdictions worldwide. Other product and service names might be trademarks of IBM or other companies. A current list of IBM trademarks is available on the Web at Copyright and trademark information at ibm.com/legal/copytrade.shtml Wind River is a world leader in embedded and mobile software. We enable companies to develop, run, and manage device software faster, better, at lower cost, and more reliably. www.windriver.com 2010 Wind River Systems, Inc. The Wind River logo is a trademark of Wind River Systems, Inc., and Wind River, Simics and VxWorks are registered trademarks of Wind River Systems, Inc. Linux is a registered trademark of Linus Torvalds in the United States, other countries, or both. References in this publication to IBM products or services do not imply that IBM intends to make them available in all countries in which IBM operates. The information contained in this documentation is provided for informational purposes only. While efforts were made to verify the completeness and accuracy of the information contained in this documentation, it is provided as is without warranty of any kind, express or implied. In addition, this information is based on IBM s current product plans and strategy, which are subject to change by IBM without notice. IBM shall not be responsible for any damages arising out of the use of, or otherwise related to, this documentation or any other documentation. Nothing contained in this documentation is intended to, nor shall have the effect of, creating any warranties or representations from IBM (or its suppliers or licensors), or altering the terms and conditions of the applicable license agreement governing the use of IBM software. IBM customers are responsible for ensuring their own compliance with legal requirements. It is the customer s sole responsibility to obtain advice of competent legal counsel as to the identification and interpretation of any relevant laws and regulatory requirements that may affect the customer s business and any actions the customer may need to take to comply with such laws. Please Recycle RAW14217-USEN-00