Make (install from source) python without running tests
The configure option --enable-optimizations enables running test suites to generate data for profiling Python. The resulting python binary has better performance in executing python code. Improvements noted here
From configure help:--enable-optimizations Enable expensive optimizations (PGO, etc). Disabled by default.
From wikipedia
profile-guided optimisation uses the results of profiling test runs of the instrumented program to optimize the final generated code.
In short, you should not skip tests when using --enable-optimizations as the data required for profiling is generated by running tests. You can run make -j8 build_all
followed by make -j8 install
to skip tests once(the tests would still run with install
target), but that would defeat the purpose.You can instead drop the configure flag for better build times.
I did some (quick) research on skipping the test runs when building Python by instructing either:
- configure - passing some args (e.g.
--without-tests
,--disable-tests
,--skip-tests
) - make - specifying some variable (either via env vars or cmdline)
The former yielded no results. The latter (by looking in the Makefile template) revealed the fact that test execution is invoked by calling ${PYTHON_SRC_DIR}/Tools/scripts/run_tests.py (which sets some stuff and calls another script, which calls another one, ...).
Note that I found the file on Python 3.5(.4) and Python 3.6(.4) but not on Python 2.7(.14). A little bit more research revealed that it is possible to skip the (above) test run. What you need to do is:
make -C dl/Python-${PYTHON_VERSION} -j8 EXTRATESTOPTS=--list-tests install
Notes:
- Googleing didn't reveal anything (relevant) on EXTRATESTOPTS, so I guess it's not officialy supported
- You could also set
EXTRATESTOPTS=--list-tests
as an environment variable, before launching (inner) make - Needless to say that if some "minor" error happened during build (e.g. a non critical external module (like _ssl.so for example) failed to build), there will be no tests to fail, so you'll only find about it at runtime (which would be terribly nasty if it would happen in production)
@EDIT0:
After @amohr 's comment, I decided to play a little bit more, so I ran the whole process:
- configure (opts)
- make (opts)
make install
on a Lnx (Ubtu 16) machine with 2 CPUs, where one (full) test run takes ~24 minutes. Here are my findings (Python 3.6):
- It ran successfully on Python 3.5(.4)
- The solution that I suggested earlier, operates at the 3rd step, so it only skips the 2nd test run: it operates on the (root) Makefile's test target (
make test
) which is invoked by install target Regarding the 1st test run, by checking the Makefile, and make's output, here's what I discovered that happens at the 2nd (make) step:
- The C sources are built "normally"
- Tests are being run (I deducted that some profile data is stored somewhere)
- The C sources are rebuilt with different flags (e.g. in my case gcc's
-fprofile-generate
was replaced by-fprofile-use -fprofile-correction
(check [GNU.GCC]: Options That Control Optimization for more details)) to make use of the profile info generated at previous (sub) step
Skipping the 1st test run would automatically imply no optimizations. Way(s) of achieving:
make build_all
(at 2nd step) - as suggested by other answersHere's a snippet of the (root) Makefile generated by configure (with
--enable-optimizations
):all: profile-optbuild_all: check-clean-src $(BUILDPYTHON) oldsharedmods sharedmods gdbhooks \ Programs/_testembed python-config
And here's one without it:
all: build_allbuild_all: check-clean-src $(BUILDPYTHON) oldsharedmods sharedmods gdbhooks \ Programs/_testembed python-config
As seen, running:
configure --enable-optimizations
make build_all
is identical to:
configure
make
Manually modifying the (root) Makefile between 1st (
configure --enable-optimizations
) and 2nd (make) steps:- Find the macro definition
PROFILE_TASK=-m test.regrtest --pgo
(for me it was around line ~250) - Add
--list-tests
at the end - Substeps (#2.)#1. and (#2.)#3. are exactly the same, while for (#2.)#2., the tests are not being run. That can mean that either:
- The 2nd sources build is identical to the 1st one (which would make it completely useless)
- The 2nd does some optimizations (without having any information), which means that it could crash at runtime (I think / hope it's the former case)
- Find the macro definition