QNX employees are considered subject matter experts in many fields; that’s why you’ll find us delivering numerous technical sessions throughout the conference.
Getting software to run on a multi-core processor is, in many cases, fairly easy. The real challenge lies in getting software to make full use of all cores. This session examines various models for multi-core processors and their support for parallel software execution. It also discusses how developers can use POSIX threads and symmetric multiprocessing (SMP) to create multiple tasks that run in parallel on a multi-core chip. Finally, it provides examples of multi-core optimization techniques and explain how developers can use visualization tools to characterize system behavior and measure performance improvements.
Key take-awaysThis session explores where and why real time is required, various definitions of real time, and the effect of the OS on a realtime design. It also examines design methods and programming-language features appropriate for real time; identify OS requirements for real time (pre-emptible kernel, priority inversion avoidance, nested interrupts, time partitioning, etc); and explore the tradeoffs between using a general-purpose OS or a realtime OS. Practical issues, such as setting appropriate task priorities and avoiding high-frequency interrupts, will also be covered.
Key take-awaysGUIs have become a key market differentiator for an array of embedded products. Users no longer want static displays; they now expect dynamic, attractive, and in many cases, customizable GUIs. As a result, embedded GUIs have become highly sophisticated, often combining multiple graphics layers or displays with dynamic 2D or 3D applications. But no matter how sophisticated an embedded GUI becomes, it must remain reliable, scalable, and, of course, memory and CPU efficient. This session explores how developers and system designers can satisfy these many requirements while leveraging standards such as OpenGL ES and Adobe Flash. Topics include achieving maximum utilization of available hardware, reducing memory footprint, implementing fault tolerance, and ensuring immediate response to user input.
Key take-awaysSoftware bugs that make it to market not only lead to incorrect system behavior and low system availability, but also result in unhappy (and fewer) customers. Unfortunately, conventional debugging methods can themselves interfere with the availability, performance, and correct behavior of the affected system. Consequently, this session explores debug and information-gathering techniques that can maintain system availability while generating artefacts that help diagnose and resolve software failure.
Key take-awaysBy writing and debugging a device driver in user space, you can make memory violations easier to catch, diagnose problems with powerful source-level debuggers, and eliminate the need to reboot your target system every time the driver faults. Using code examples, this session guides you through the basic steps of writing a user-space driver: manipulating hardware registers, accessing memory locations, handling interrupts, and implementing inter-process communication (IPC) between the driver and its clients. Depending on underlying OS, the driver can often remain in memory-protected user space at runtime. The result is a driver that is both well-tested and well-protected.
Key take-awaysTo satisfy growing demand for new features, embedded designers must create scalable systems that can quickly support new applications and services. Nonetheless, customers still expect these systems to deliver high levels of reliability and service availability: the failure or dynamic replacement of one service cannot compromise the availability of the remaining services. This session examines steps required to achieve these goals. We will discuss software practices that improve MTBF (mean time between failures) and MTTR (mean time to repair), such as decoupling software components, minimizing serial dependencies, and using redundant components. We will also discuss software watchdogs, which detect process failures and restart faulty processes, and time partitioning, which guarantees CPU time for critical services, including fault-detection mechanisms.
Key take-awaysFor many embedded systems, fast boot times are an absolutely necessity. For other systems, fast boot times serve as a product differentiator or simply make the system more convenient for the end user. In either case, to boot quickly and to then perform a set of actions within a strict timeline, a system must be designed with early boot requirements in mind. To help address this challenge, this session explores several techniques for both cold booting and warm booting, including multi-stage booting, mini drivers, splash screens, OS image restoration; hibernation mode, and fast boot techniques specific to x86 systems.
Key take-aways