What is the difference between machine dependent and code optimization?
Machine dependent code is in contrast to machine-independent, or
portable, code.
Optimized code is in contrast to non-optimized code.
The two terms do not contrast each other; machine dependent code
can be optimized or not optimized, and so can machine independent
code.
Machine-dependent code relies on specific characteristics of the
device it was written for. For example, it might depend on an
integer variable to be 16 bits in size, or on a specific memory
address to gain access to special hardware features (such as, for
example, a ratl-time clock or serial port). Machine-dependent code
is common in embedded software, which is generally written to suit
small and specialized computer systems. It can be difficult to
transport this code to a different machine due to these machine
dependencies.
Machine independent or "portable" code contains fewer and,
ideally, no such dependency. In theory, such code can be freely
moved from one machine to another, provided all share support for
the same programming language such as, for example, ANSI-C.
In reality however, no code is truly independent. Portable code
may not depend on the size of an integer variable or the memory
location of a serial port chip, but will instead depend on other
factors. For example, it will depend on an ANSI compliant
implementation of the C programming language, and an operating
system with a standard POSIX API.
Code optimization, by contrast, does not necessarily introduce
machine dependency. Many forms of machine dependence introduced by
optimization are introduced by automated optimization steps. For
example, the C compiler for machine A may be able to optimize code
for this particular machine for fastest excution or smallest size
(or a compromise of both). Since this hardware-dependent
optimization occurs at a lower level than the C programming, it is
not a concern for portability.
Other optimization steps can introduce machine dependency into
the source code. For example, accessing a time-critical I/O device
through operating system device drivers may lead to unacceptable
latencies in some application. One might then decide to accept the
disadvantage of machine dependencies on this occasion in order to
meet the required timing constrains.
It is generally advisable to introduce such dependencies with
great care and only after careful consideration, and to the
smallest amount possible.