c - PORTABILITY AND PERFORMANCE

[nixawk]

Code is often developed on one type of computer and then
ported to and executed on another. Therefore, it is judicious to
make the code as portable as possible, requiring no changes or
minimal ones—such as changes to system-specific header files.
When writing software, consider the following guidelines that
will enhance portability and performance.

Guidelines for Portability

• Use ANSI C whenever it is available.

• Write portable code first. Consider detailed optimizations only on computers
  where they prove necessary. Optimized code is often obscure.
  Optimizations for one computer may produce worse code on another.
  Document code that is obscure due to performance optimizations and isolate
  the optimizations as much as possible.

• Some code/functions are inherently nonportable. For example, a hardware
  device handler, in general, can not be transported between operating systems.

• If possible, organize source files so that the computer-independent code and
  the computer-dependent code are in separate files. That way, if the program
  is moved to a new computer, it will be clear which files need to be changed for
  the new platform.

• Different computers have different word sizes. If you are relying on a
  (predefined) type being a certain size (e.g., int being exactly 32 bits), then
  create a new type (e.g., typedef long int32) and use it (int32) throughout the
  program; further changes will require only changing the new type definition.

• Note that pointers and integers are not necessarily the same size; nor are all
  pointers the same size. Use the system function sizeof(...) to get the size of a
  variable type instead of hard-coding it.

• Beware of code that takes advantage of two’s complement arithmetic. In
  particular, avoid optimizations that replace division or multiplication with
  shifts.

• Become familiar with the standard library and use it for string and character
  manipulation. Do not reimplement standard routines. Another person reading
  your code might see the reimplementation of a standard function and would
  need to establish if your version does something special.

• Use #ifdefs to conceal nonportable quirks by means of centrally placed
  definitions.

Example: centrally placed definitions

#ifdef decus
#define UNSIGNED_LONG long
#else
#define UNSIGNED_LONG unsigned long
#endif

[nixawk]

Guidelines for Performance

• Remember that code must be maintained.
• If performance is not an issue, then write code that is easy to understand
  instead of code that is faster. For example,

replace:    d = (a = b + c) + r;    with:    a = b + c;
                                                                d = a + r;

• When performance is important, as in real-time systems, use techniques to
  enhance performance. If the code becomes “tricky” (i.e., possibly unclear),
  add comments to aid the reader.

• Minimize the number of opens and closes and I/O operations if possible.

• Free allocated memory as soon as possible.

• To improve efficiency, use the automatic increment ++ and decrement
  operators -- and the special operations += and *= (when side-effect is not an
  issue).

• ANSI C allows the assignment of structures. Use this feature instead of
  copying each field separately.

• When passing a structure to a function, use a pointer. Using pointers to
  structures in function calls not only saves memory by using less stack space,
  but it can also boost performance slightly. The compiler doesn’t have to
  generate as much code for manipulating data on the stack and it executes faster.