|TECH FOCUS: THE CARE AND FEEDING OF COMPILERS|
|A critical component in every embedded system developer'srepertoire of software tools is the compiler, which transforms sourcecode, generally written in a language such as C or C++, into a machineor object code form that a target microprocessor can understand andexecute.
As simple as this sounds, the process is fraught with complexity,for the compiler must perform a range of operations – lexical analysis, preprocessing, parsing, semantic analysis, code generation and optimization – to be sure that what goes in is what comes out. Because of the critical importance of this process, a lot of effort is spent on Embedded.com getting good how-to articles on the proper care and feeding of compilers.
At one end of the spectrum are back-to-the-basics articles byauthors such as Jack Ganssle on writing compiler friendly C code, and using C-compilers to reduce code size ,WayneWolff on basic MCUcompilation techniques , and Greg Davis on the details of programming withmodern compilers .
At the other end are articles for experienced programmers on suchtopics as usingcompilers to effectively allocate memory , the use of omniscientcode compilation on 32-bit MCUs, architecture-oriented C compiler codeoptimization, verifying compilers foruse in safety critical apps, compiler optimization for DSPand compiler support formultiprocessor SoC designs.
Most recently, in my Editor's TopPick “Tuning C/C++compilers for optimal parallel performance in multicore apps ,” Intel's Max Domeika details in a two-part series, the important C/C++compiler scalar optimization and performance features that will allowyou to take full advantage of the parallelism in your design. And in ESD Magazine's “When good compilersgo bad ,” authors Paul Anderson and Thomas W. Reps go intohow to get rid of the mismatch between source code and compiled machinecode that causes so many problems, and present some of the latestresearch into finding tools that combat the problem. (Embedded.com EditorBernard Cole, firstname.lastname@example.org )
|EDITOR'S TOP PICK by Bernard Cole, Embedded.com Editor|
|Tuning C/C++ compilers for optimal parallel performance in multicore apps: Part 1
Max Domeika, author of “Software development for embedded multicore systems,” details C and C++ compiler scalar optimization and performance features that will allow you to take full advantage of parallelism via multithreading or partitioning. Part 1: Why scalar optimization is so important.
|ESD MAGAZINE: Online Exclusive|
|When good compilers go bad, or What you see is not what you execute
Getting rid of the mismatch between source code and compiled machine code may mean having to debug the machine code. Here's some of the latest research on finding a tool to combat the problem.
|TECH FOCUS: Using C/C++ Compilers Effectively|
|Back to the Basics – Practical Embedded Coding Tips: Part 6
In this six part series excerpted from a recent book for students, Jack Ganssle and Jakob Englom deal with the many embedded C-language coding problems and gotchas and provides some helpful hints on how to resolve them. Part 6: Writing compiler-friendly C-code.
|The basics of programming embedded processors: Part 3
In this third part in a eight part series, Wayne Wolf delves into all aspects of compiler design and use, and how models can help in the development of embedded system code. This week: basic compilation techniques.
|If Size Doesn't Matter, Why Does My Memory Cost So Much?
Compiler enthusiast Guy Goldstein provides some programming tips on how to use your compiler to more effectively allocate memory as well as some tip for picking the right compiler.
|Guidelines for writing efficient C/C++ code
Greg Davis of Green Hills explains the details of programming with modern compilers and how to get good performance using the right choice of data types, variable scopes, the restrict keyword, floating point arithmetic, assembly statements, packing, and loop optimizations.
|How to verify your compiler for use in IEC 61508 safety-critical applications
Richard Barry describes step-by-step what is necessary to satisfy the IEC61508 safety-critical requirements for compiler verification using a very rapid low-risk compliance framework.
|Providing memory system and compiler support for MPSoc designs: Part 3
In a three part series, the authors, contributors to “Multiprocessor Systems-On-Chip” look at the variety of uniprocessor memory architectures and assess their usefulness in multicre designs. Part 3: Compiler support architectures.
|Lower MCU power consumption by using omniscient code generation
Using omniscient code generation, compilers can have a significant effect on the number of instructions needed for apps on 8-/16-bit MCUs, significantly reducing power consumption.
|Compilation strategies for the PIC32
Unlike conventional compilation that optimizes and generates object code independently for each individual program module, omniscient compilation optimizes based on a view of all modules, across the entire program.
|Architecture-oriented C optimization, part 1: DSP features
Here's how C optimizations can take advantage of zero overhead loop mechanisms, hardware saturation, modulo registers, and more.
|Compiler optimization for DSP applications
Here's how to use compilation options to improve performance in DSP applications.
|Using whole-program compilation to improve MCU code density and performance
Clyde Stubbs of HI-TECH Software describes a new approach to microcontroller code development that substitutes a more efficient global compilation methodology for the current module-by-module approach.
|A new approach to improving system performance
Here's how significant performance increases can be achieved when acceleration techniques are applied to software that resides above the operating system.
|Designing for performance with software optimization
Optimization of your embedded software application should not be a final step in project development, but rather an ongoing design philosophy that begins from the planning stages all the way through completion.
|The basics of programming embedded processors: Part 5
In this fifth in a eight part series, Wayne Wolf delves into all aspects of compiler design and use, and how models can help in the development of embedded system code. This week: register allocation and scheduling.
|Back to the Basics – Practical Embedded Coding Tips: Part 5
In this six part series, Jack Ganssle and Jakob Englom deal with the many embedded C-language coding problems and gotchas and provides some helpful hints on how to resolve them. Part 5: Using your C-compiler to minimize code size.
|Optimizing Compilers and Embedded DSP Software
Understanding the DSP architecture, the compiler, and the algorithms can help you speed up applications by an order of magnitude. This article summarizes techniques that can improve performance in terms of cycle count, memory use, and power consumption.
|EDITOR'S NOTE by Bernard Cole, Embedded.com Editor|
|If you want to learn how to deal with the inevitable signal-integrity problems in your design, check out the TechOnLine course: Fundamentals of Signal Integrity. It will take you from a basic definition of signal integrity and what can cause it to deteriorate, right through to the interpretation of an eye diagram and how use the latest test equipment to spot problems.
Also, to learn more about multicore design using Linux check out the new Live Webinar: “Optimized Linux Development Tools for Multicore”. Presented by Alex deVries, Chief Linux Technologist, and Emeka Nwafor, Director of Product Management, Development Tools, both from Wind River Systems, it covers the basics of how to use Wind River's Eclipse based visualization enhancements to Linux command line tools to migrate existing code or developing new code for a multicore processor.