This build system has served us well for about twenty years, but
time has come to part. ROOT can be built with CMake (the de-facto
standard for many software packages out there) since several years
now. It's not a beauty, but it works. And we have better things to
do than maintain two independent build systems. Thus:

  So long, configure, and thanks for all the bash!

It seems my last commit doesn't properly implement the way we
add a define to the dictionary. It seems this is the proper way
to do it instead of just calling add_definitions.

Obviously we shouldn't activate C++ modules when people want Imt.

It was removed for std::string_view, and we do not need to test for it specifically.

* Add parallelization to Chi2 fitting.

- Adapt vectorized TF1 for a Fitter with fixed parameters.
- Made the Chi2FCN Evaluating loop independent of the size of the SIMD array.
- Parallelized both vectorized and scalar versions of the Chi2FCN evaluation.
- Added new fExecutionpolicy field to the Chi2FCN class that will determine the policy to use for the chi2 function evaluation: multiprocess, multithread or serial(none).

* Provide automatic chunking in parallel Chi2 Fit

* Change naming in template resolver

* Fix error calling EvalParVec with ftype=1

* Template Paramfunctor

Templates Paramfunctor and adds const parameters interfaces for evaluation.

* Add vectorized Chi2 Evaluation

* Add Functor type resolving to TF1

* Vectorize and parallelize unbinned likelihood fit

* Introduce the Double_v type

* Linked MathCore with Vc

* Prepare for chunking

* Adapt Fitter interfaces for vectorization

* Improve use of VecCore

* Change Mathcore linking from Thread to IMT

* Allow the evaluation of Chi2 with coord errors

* Improve identation

* Disable the multiprocessing of the fitting

* Cleaned remaining Vc directives

* Link vecCore instead of Vc

* Define R__HAS_VECCORE

* Differentiate VecCore code at compile time

* Fix warning due to unused args

* Restore original conditions for Chi2Evaluation

* Make fFunctor transient again

* Reenable Chi2Gradient and Chi2Residual evaluations

* Add ValuePtr documentation

* Fix white lines between functions

* Fix Chi2 evaluation of multidimensional data

* Fix Memory alignment in the vectorized Likelihood fit.

This reintroduces Vc dependencies

* Fix for classic builds

* Conditionate MathCore linking

* Only Fit Multithreaded if IMT is enabled

* Fix multidim integral error in the Chi2 fit

* Fix LogL evaluation of multidimensional unbinned data

* Improve VecCore usage

* Simplify fFunctor check expressions

* Move the Double_v type into the ROOT namespace

* Make executionPolicy an enum

* Explain functor operator resolving in TF1

* Improved TF1::fType documentation

* Adapt execution policy option of the histogram fit

* Completed move of executionPolicy to a enum

* Add tests for the new parallel fitting.

This tests check both Chi2 and Unbinned LogL fitting in each one of the
execution policies available.

* Correct function naming

* Rename global variables to supress shadowing warning.

* Remove legacy parallel implementations

This reverts commit 5c076c6c.

This reverts commit b406328d, reversing
changes made to 318c7a47.

Implement the necessary scaffolding and install headers only if IMT is enabled.

When building modules with clang from the trunk we need to build with gcc's
libstdc++. Apparently this can be done in clang in 2 ways:
  1. Building clang with -DGCC_INSTALL_PREFIX=$(dirname `which gcc`)/../
     This would hardcode the patch to the gcc toolchain when compiling clang.
  2. Pass on every compiler invocation --gcc-toolchain=$(dirname `which gcc`)/../
     This allows relocatability of the toolchain.

I decided to implement the second option and got stuck with implementing it in
cmake. One of the reasons was I was unable to pass --gcc-toolchain early enough
and try_compile fails at very early stages.

Finally I decided to go for the first option hardcoding the gcc toolchain path
at clang built time. This is sufficient for modules.

This commit serializes the progress I did on 2 in configure make. Now we can
configure with --gcc-toolchain in configure-make.

Works for both cmake and classic builds.

ROOT uses builtin gl2ps sources, but has no switch to use the system
library instead. This adds this missing option.

ROOT uses builtin unuran sources, but has no switch to use the system
library instead. This adds this missing option.

The configure script currently uses a simple grep to determine if an option
is deprecated. This causes problems, since the enable-reflex option is
deprecated and grepping for enable-r will result in a match. The configure
script therefore considers enable-r deprecated too, even though it is not.
This commit addresses this issue.

Build with cmake works as it downloads latest Vc.

Signed-off-by: Fons Rademakers <Fons.Rademakers@cern.ch>

Although it is not anymore the base build system, adding tbb support was
not too complicated and allows still easy testing of this new feature.
Use ./configure --enable-tbb. TBB needs to be preinstalled, there is no
support for the on the fly TBB installation featured supported by cmake.

This commit provides a task-based parallelisation of
TTree::GetEntry. The approach is based on creating a task per
top-level branch in order to do the reading, unzipping and
deserialisation in parallel.

Remove the ugly cxxmodule workarounds in graf3d: they don't really work anyway.
Instead, explicitly disable building with cxxmodules graf3d on macos due to
glew. Disable building with cxxmodules libs which still have bugs.

Improve the build system implementation scaffolding for cxxmodules.

Finally, with the introduced infrastructure and workarounds, ROOT builds and
runs with cxxmodules on (given one has newest clang, with my pending for
mainline patch). It seems that roottest is almost happy, too.