Re: Two strange messages while building Emacs on MS-Windows

[Eli Zaretskii]

> From: Stefan Monnier <address@hidden>
> Cc: address@hidden,  address@hidden
> Date: Sun, 09 Dec 2012 10:50:31 -0500
> 
> > The more important reason is that byte compilation on Windows during
> > bootstrap is done sequentially, whereas on Unix it's done in parallel
> > (under "make -j").
> 
> I do "make -j2" and get about %170 of cpu utilisation (most of the
> less-than-100% is due to phases in the build process where we only have
> one process running, such as when running `configure'), so presumably my
> 6min would turn into no more than 10min if run sequentially.

Indeed, I get 10min 40sec for sequential compilation with Emacs whose
byte compiler was byte-compiled.  This is on a 3.4GHz Core i7, which
is probably faster than your cores.

With the changes I committed in revision 111166, lisp/makefile.w32-in
now allows for 4-way parallelism while byte-compiling, which slashes
the byte compilation times from 10:40 to 3:35 if I use "make -jN" with
N >= 4.

The above is with byte-compiled byte compiler.  If I do the same with
the interpreted byte compiler, the sequential compilation takes 12:30
while the parallel compilation takes 4:40 -- slower, but not by a
large margin, only 25% slowdown.  A full bootstrap with "make -j8"
takes about 6 minutes.

> Still pretty far from his 30min, so while "make -j" would help, the
> inefficiency of the bootstrap is at least as important in his specific
> case, I think.

I cannot explain 30 min, since I never get such long times here.  One
possible reason could be that Dani uses an MSYS Make, which doesn't
support parallel execution (the MinGW Make does in its latest
builds).  Another potential difference between what I do and what Dani
does is that Dani uses MSYS Bash, while I use cmd.exe.  But I can
hardly believe that MSYS Bash slows down things so much.

Yet another possible reason could be that Dani runs a 64-bit Windows 7
while I did the above measurements on a 32-bit XPSP3.  Recently I
found out that running 32-bit executables on 64-bit Windows OS incurs
a tangible penalty.  But my own measurements of byte compilation on
Windows 7 show only 2-fold slowdown, which still brings us only to
around 20 min or so, not 30.  A mystery.