The following is a list of architectures supported by Owl, their
flavors and various architecture-specific details.


	Architecture flavors.

On many architectures, Owl supports multiple flavors (or versions) of
the architecture.  For example, i386 and i686 are both versions of the
x86 (IA32) architecture.  It is possible (and in fact recommended, in
most cases) to build and/or use binary packages intended for an older
version of the architecture on your modern hardware.

Packages built for an architecture flavor closest to that implemented
in your CPU may provide a small performance improvement (usually 1 to
5% overall on real-world tasks).  However, there's a price: you won't
be able to move such packages to an older machine and install there.
Worse, you may not be able to build packages (or any binaries) for an
older architecture flavor on a system where the development libraries
were built for a newer one.  The packages will appear to build and
work, but may in fact require the newer architecture flavor due to
code inherited from development libraries installed on the system.

There are two possible solutions to this last problem: you may choose
to only use packages for the oldest architecture flavor you may ever
need, or you may install development libraries built for the older
flavor while using other packages (including dynamic libraries) built
for your actual hardware.  It is likely that you will find the first
solution more practical, even though it doesn't provide the best
possible performance.

Note that packages built for an older architecture flavor may be tuned
for your newer CPU, to the extent possible within the feature set of
the older flavor.  This is how all Owl packages are built by default.


	Building for a particular architecture flavor.

Architecture flavor may be specified via the ARCHITECTURE= line in
buildworld.conf.  This line is optional and commented out by default,
in which case the oldest flavor of the build host's architecture is
selected.

Cross-builds are not supported: it is not possible to build packages
for an architecture different than that of the build host, nor for a
flavor of the architecture newer than that implemented in the build
host's CPU.


	x86, also known as IA32.

Two architecture flavors are defined by default: i386 and i686.  The
i386 produces packages that will actually run on an i386 or on any
newer CPU.  Both the i386 and the i686 packages are tuned for an i686,
with the only difference being that the i686 packages make use of the
instructions only available with this newer architecture flavor.

It is recommended that you only use i386 packages, as the performance
improvement with the i686 is minimal (less than 1% overall).


	SPARC.

Two architecture flavors are defined: sparc and sparcv9.  The sparc
assumes at least a SPARC V8, and both produce packages tuned for an
UltraSPARC.  The sparcv9 packages will actually not work on anything
below an Ultra.

The performance improvement with the sparcv9 is minimal (1 to 2%,
except for certain functions in glibc and OpenSSL where SPARC V9
assembly versions are provided).

sparc64 is not supported at this stage.  It is possible to build Owl
userland (32-bit) while running a sparc64 kernel, though.


	Alpha.

Two architecture flavors are defined by default: alpha and alphaev56.
The choice affects both the use of BWX extensions with alphaev56 and
instruction scheduling.  That is, packages built for plain alpha
target are tuned for older EV4 processors (21064, 21066) and ones
built for alphaev56 are tuned for EV56/PCA56 processors (21164A,
21164PC).  On an EV5 (21164) processor you may use the suboptimal
plain alpha packages.  On an EV6+ (21264, 21264A), use the alphaev56
packages.

$Owl: Owl/doc/ARCHITECTURES,v 1.6 2005/12/29 21:04:00 solar Exp $
