gronod/lfs
1
0
Fork 0
mirror of https://git.linuxfromscratch.org/lfs.git synced 2025-03-05 22:04:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rewording the SBUs section.

Browse Source 
git-svn-id: http://svn.linuxfromscratch.org/LFS/trunk/BOOK@2719 4aa44e1e-78dd-0310-a6d2-fbcd4c07a689
This commit is contained in:
Alex Gronenwoud 2003-09-02 21:59:26 +00:00
parent 7fcbee1c5f
commit dc37bc5188
1 changed files with 20 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
chapter02/aboutsbus.xml
View File

@ -2,28 +2,29 @@
<title>About SBUs</title>
<?dbhtml filename="aboutsbus.html" dir="chapter02"?>
<para>SBUs are <emphasis>Static Bash Units</emphasis> and they are our way
of identifying how long a package takes to compile. Why don't we use normal
times like anybody else?</para>
<para>Most people would like to know beforehand how long it approximately
takes to compile and install each package. But "Linux from Scratch" is built
on so many different systems, it is not possible to give actual times that are
anywhere near accurate: the biggest package (Glibc) won't take more than
twenty minutes on the fastest systems, but will take something like three days
on the slowest -- no kidding. So instead of giving actual times, we've come up
with the idea of using the <emphasis>Static Binutils Unit</emphasis>
(abbreviated to <emphasis>SBU</emphasis>).</para>
<para>The biggest problem is that times cannot be accurate, not even a
little bit. So many people install LFS on so many different systems, the
times it takes to compile something varies too much. One package may take
20 minutes on one system, but that same package may take 3 days on another
(this is not an exaggeration). So instead we've come up with a
<emphasis>Static Bash Unit</emphasis> or <emphasis>SBU</emphasis>.</para>
<para>It works like this: the first package you compile in this book is the
statically linked Binutils in Chapter 5, and the time it takes to compile this
package is what we call the "Static Binutils Unit" or "SBU". All other compile
times will be expressed relative to this time.</para>
<para>It works like this: the very first package you compile in this book
is Bash in Chapter 5 and it'll be statically linked. The time it takes to
compile this package will be the basis and called the SBU. All other
compile times are relative to the time it takes to install Bash. For
example, GCC-3.2 takes about 9.5 SBUs and it's proven that this number is
fairly consistent among a lot of different systems. So multiply 9.5 by the
number of seconds it takes for Bash to install (the SBU value) and you get
a close approximation of how long GCC will take on your system.</para>
<para>For example, the time it takes to build the static version of GCC is 3.9
SBU. This means that if on your system it took 10 minutes to compile and
install the static Binutils, then you know it will take nearly 40 minutes to
build the static GCC. Fortunately, most build times are much shorter than the
one of Binutils.</para>
<para>Note: We've seen that SBUs don't work well on SMP based machines. So
all bets are off if you're lucky enough to have an SMP setup.</para>
<para>Note that SBUs don't work well for SMP-based machines. But if you're so
lucky as to have multiple processors, chances are that your system is so fast
that you don't mind.</para>
</sect1>