RSS
Green Hills Software
Hall 4, Stand 325
Theatre Presentation
Solving complex embedded problems
For thirty years, Green Hills Software has solved the most challenging problems in embedded software. The presentation and live demonstration will show Green Hills Software's leadership in performance optimization, tools and techniques for maximizing developer productivity, and expertise in building safe, secure, and reliable embedded software.
Attendees to our
in-stand theatre presentations will
receive a free 8GB
USB Flash Drive.
Stand Kiosks
Safety-Qualified Tools
When developing a safety-critical system, the choice of best-in-class, pre-qualified tools can save significant time throughout the development process. Green Hills Software will demonstrate the MULTI IEC 61508:2010 (SIL4), EN 50128:2011 (SWSIL4) and ISO 26262 (ASIL D) pre-qualified tool suite on a Xilinx Zynq ZC702 board. The demonstration will run an application on the INTEGRITY RTOS and include the powerful TimeMachine debugger that takes advantage of live CPU on-chip generated trace data.
High Performance Virtualization of AutoDroid on OMAP™ 5 Processors
A securely virtualized Android Jelly Bean-based platform tailored to the needs of automotive infotainment manufacturers and OEM's. The platform features the world's first ARM Virtualization Extension (VE) enabled hypervisor, INTEGRITY Multivisor, running on a Texas Instruments, Inc. (TI) OMAP™ 5 processor. Multivisor's unique architecture provides hard real time capabilities with fast boot performance for "instant on" safety functions like rear view camera, while securely separating open application environments — providing a rich Android experience in a safe, reliable manner for in-vehicle infotainment needs.
INTEGRITY Secure Smartphone - Trusted Mobile Device
INTEGRITY Secure Smartphone Trusted Mobile Device (INTEGRITY-TMD) delivering the next generation of trusted mobile platforms. This commercially available standard platform features the industry-leading INTEGRITY Multivisor, running on a Texas Instruments, Inc. (TI) OMAP4460 processor. The INTEGRITY Secure Smartphone securely separates Android open application environments with safe device, network and storage access and management to the guest operating system - providing a rich Android experience in a safe, reliable manner for commercial, government and enterprise use.
Advanced Graphics
Next-generation devices need modern graphics capabilities. Green Hills Software will demonstrate OpenGL 3D capabilities for the INTEGRITY RTOS on a Freescale i.MX6 Quad-core CPU and a Fujitsu Emerald-P platform. The combination of a high performance OpenGL stack with the safe, secure and real-time INTEGRITY separation kernel allows creation of robust devices, such as an automotive cluster or Class II-III medical devices.
MULTI for Embedded Linux
High-quality, feature-rich, non-intrusive debugging tools dramatically reduce time to market and device quality. Green Hills Software will demonstrate the capabilities of the MULTI tools suite targeting embedded Linux, including its best-in-class compiler, and multi-thread, multi-core source-level debugger.
February 26 - 28 • Nuremberg, Germany • Hall 4 • Stand 325
Green Hills Software's embedded software technology thought-leaders will present technical sessions in the Embedded World conference, demonstrate optimized solutions on our stand (Hall 4, Stand 325), and present in our in-stand theatre to help embedded designers build and deploy software with maximum performance, absolute security, in the fastest time-to-market. Green Hills will also present and demonstrate its leading support for today's latest processors.
Attendees to our in-stand theatre presentations will receive a free 8GB USB Flash Drive.
embedded world Conference (CCN East) sessions by Green Hills Software
Writing Secure and Reliable C/C++ Code (Part I of II)
When:
Where:
Who:
Synopsis:
Tuesday, 26 February, 12:00 – 12:45
Session 02: Software Development in
High Level Languages 1
Greg Davis, Director of Compiler Engineering, Green Hills Software
Simple coding techniques can make your embedded system more secure and reliable. Does this sound too good to be true? Software engineering has become the most expensive aspect of many kinds of embedded product development. Software is also one of the more problematic aspects as software bugs plague products long after the last hardware problems have been resolved or worked around. Thus, it is not surprising that much has been written about improving software engineering practices. Much of this has to do with the practice of how to design, program, and test your programs in the most efficient manner Regardless of the software engineering methodology employed, there are low level decisions that are usually left up to the individual developer. Although most organizations have some kind of coding guidelines, these often focus on issues like naming variables and indentation style. This paper will suggest some low-level coding guidelines that are applicable to almost all approaches to software engineering. While, nobody can promise you perfectly reliable code, these steps will surely take you in the right direction.
Writing Secure and Reliable C/C++ Code (Part II of II)
When:
Where:
Who:
Synopsis:
Tuesday, 26 February, 13:45 – 14:30
Session 02: Software Development in
High Level Languages 1
Greg Davis, Director of Compiler Engineering, Green Hills Software
Simple coding techniques can make your embedded system more secure and reliable. Does this sound too good to be true? Software engineering has become the most expensive aspect of many kinds of embedded product development. Software is also one of the more problematic aspects as software bugs plague products long after the last hardware problems have been resolved or worked around. Thus, it is not surprising that much has been written about improving software engineering practices. Much of this has to do with the practice of how to design, program, and test your programs in the most efficient manner. Regardless of the software engineering methodology employed, there are low-level decisions that are usually left up to the individual developer. Although most organizations have some kind of coding guidelines, these often focus on issues like naming variables and indentation style. This paper will suggest some low-level coding guidelines that are applicable to almost all approaches to software engineering. While, nobody can promise you perfectly reliable code, these steps will surely take you in the right direction.
Guidelines for Writing Efficient C/C++ Code
When:
Where:
Who:
Synopsis:
Tuesday, 26 February 2013, 15:30 – 16:30
Session 01: Ultra Low Power Solutions
– the Basics
Greg Davis, Director of Compiler Engineering, Green Hills Software
With ineffective programming, even a perfect compiler can not generate efficient code. This ninety minute talk will focus on the hows and whys of programming with today's modern compilers and how to get good performance out of them. Examples will be given to illustrate how simple source code transformations can result in big savings regardless of the compiler used. The talk will cover choice of data types, variable scopes, the restrict keyword, floating point arithmetic, assembly statements, packing, loop optimizations, and volatile memory.
Guidelines for Writing Portable Code
When:
Where:
Who:
Synopsis:
Wednesday, 27 February, 09:00 – 10:00
Session 09: Software Development in High Level Languages 2/I
Greg Davis, Director of Compiler Engineering, Green Hills Software
Today's fastest, lowest power processor will be outdated tomorrow, leaving the developer locked into obsolete technology, unable to move to a new processor. Writing portable code can help minimize the risk by making the migration to newer processor or software technology as painless as possible. This talk will focus on coding guidelines that take nothing for granted, leaving the programmer with a portable code base, ensuring access to the latest technology.
Engineering Principles for High Assurance Software
When:
Where:
Who:
Synopsis:
Wednesday, 27 February, 16:00 – 16:30
Session 07:
Functional Safety Systems II
Andre Schmitz, Field Applications Engineer, Green Hills Software
The past has shown that software bugs in critical software components, like in medical or industrial equipment, can lead to severe problems. That's why in many areas of the embedded software industry efforts are made to increase the quality and reliability of the deployed software. This is mainly reflected in the design of the software architecture and in the development process. If we look at products where the highest safety or security is mandatory, we find a certain set of principles being applied to the software architecture and the engineering process which are proven to result in high-assurance software. This talk will discuss a few historic software failures and how a process for high-assurance software engineering can help to prevent those kinds of problems.
Advanced Compiler Optimizations for Smallest, Fastest Code
When:
Where:
Who:
Synopsis:
Thursday, 28 February, 09:00 – 10:00
Session 20: Software
Development in High Level Languages 3
Greg Davis, Director of Compiler Engineering, Green Hills Software
Embedded software developers, much more so than other software engineers, are concerned with their software at multiple levels. Since these days the vast majority of code is written in high level languages, the translation process between high level languages and machine assembly code, known as compilation, is crucial. Compiler technology has not yet run it course, and new cutting-edge optimizations have made enormous executation and code size savings. This talk will survey some of my favorite optimizations: some are old, but highly effective, while others are virtually unknown outside of the tight knit community of compiler developers.
Compiler Bugs in the Real World
When:
Where:
Who:
Synopsis:
Thursday, 28 February, 10:00 – 10:30
Session 20: Software Development in High Level
Languages 3
Greg Davis, Director of Compiler Engineering, Green Hills Software
Writing functional and reliable software is challenging enough without considering compiler bugs. A compiler bug, particularly one that makes your code malfunction, is a rude awakening for a software developer who is just trying to meet a deadline. This session begins with a taxonomy of compiler bugs followed by a couple real-world illustrative examples of each. Finally, it discusses how they manifest themselves and what you can do to minimize their impact on your development schedule.
When:
Where:
Who:
Synopsis:
Thursday, 28 February, 13:30 – 14:30
Session 27: Automotive Applications II
Greg Davis, Director of Compiler Engineering, Green Hills Software
C and C++ are powerful, yet compact programming languages, but they permit programming practices that are not well suited for high reliability systems. MISRA C/C++ is a collection of rules that define a subset of the languages that is less error-prone and more suitable for critical systems, such as in avionics, medical systems, and defense. This class will provide an introduction to MISRA C/C++, when it should be used, and when it should not. It will also provide an introduction to the most important rules of MISRA and how they help ensure a reliable system.
When:
Where:
Who:
Synopsis:
Thursday, 28 February, 14:30 – 15:00
Session
26: Automotive Applications
Andre Schmitz, Field Applications Engineer, Green Hills Software
The next generations of in vehicle infotainment systems promise to be as versatile and entertaining as the latest high end smartphones. However, the safety requirements in a car are certainly much higher than those of smartphones, hence the software architecture of those systems cannot just be taken over from the smartphone platforms. Instead, it needs the capabilities to consolidate different software components, such as an Android, an OEM specific software module, the instrument cluster software as well as automotive communication stacks and safety components. And all this should be able to run next to each other reliably and still interact, while sharing the access to different hardware components. This talk describes the requirements of automotive infotainment systems and discusses possible software architectures that fulfill these requirements, including different approaches using virtualization technology.
When:
Where:
Who:
Synopsis:
Thursday, 28 February, 16:30 – 17:00
Session
26: Automotive Applications
Greg Davis, Director of Compiler Engineering, Green Hills Software
While 85% of embedded designs use C and C++, these languages are notorious for their inherent lack of safety. Many of the most common sources of errors are unlikely to show up during testing, and may manifest themselves later as costly product glitches. This talk focuses on the tools and techniques that can be used to augment any software design paradigm. Techniques include coding conventions, automatic run-time error checking, manual compile-time and run-time assertions, static analysis, and the most common mistakes to avoid.
For a PDF of the complete embedded world Conference programme, please click here.