MTD 248-645A Manual de usuario descargar pdf (Pagina 50)

Linux From Scratch - Version 7.0

4.5. About SBUs

Many people would like to know beforehand approximately how long it takes to compile and install each package.

Because Linux From Scratch can be built on many different systems, it is impossible to provide accurate time

estimates. The biggest package (Glibc) will take approximately 20 minutes on the fastest systems, but could take

up to three days on slower systems! Instead of providing actual times, the Standard Build Unit (SBU) measure will

be used instead.

The SBU measure works as follows. The first package to be compiled from this book is Binutils in Chapter 5. The

time it takes to compile this package is what will be referred to as the Standard Build Unit or SBU. All other compile

times will be expressed relative to this time.

For example, consider a package whose compilation time is 4.5 SBUs. This means that if a system took 10 minutes

to compile and install the first pass of Binutils, it will take approximately 45 minutes to build this example package.

Fortunately, most build times are shorter than the one for Binutils.

In general, SBUs are not entirely accurate because they depend on many factors, including the host system's version

of GCC. They are provided here to give an estimate of how long it might take to install a package, but the numbers

can vary by as much as dozens of minutes in some cases.

To view actual timings for a number of specific machines, we recommend The LinuxFromScratch SBU Home Page

at http://www.linuxfromscratch.org/~sbu/.

Note

For many modern systems with multiple processors (or cores) the compilation time for a package can be

reduced by performing a "parallel make" by either setting an environment variable or telling the make

program how many processors are available. For instance, a Core2Duo can support two simultaneous

processes with:

export MAKEFLAGS='-j 2'

or just building with:

make -j2

When multiple processors are used in this way, the SBU units in the book will vary even more than they

normally would. Analyzing the output of the build process will also be more difficult because the lines of

different processes will be interleaved. If you run into a problem with a build step, revert back to a single

processor build to properly analyze the error messages.

4.6. About the Test Suites

Most packages provide a test suite. Running the test suite for a newly built package is a good idea because it can

provide a “sanity check” indicating that everything compiled correctly. A test suite that passes its set of checks usually

proves that the package is functioning as the developer intended. It does not, however, guarantee that the package

is totally bug free.

Some test suites are more important than others. For example, the test suites for the core toolchain packages—GCC,

Binutils, and Glibc—are of the utmost importance due to their central role in a properly functioning system. The test

suites for GCC and Glibc can take a very long time to complete, especially on slower hardware, but are strongly

recommended.

1 2 ... 45 46 47 48 49 50 51 52 53 54 55 ... 346 347

Sin comentarios

MTD 248-645A Manual de usuario Pagina 50