[WIP, CI, enhancement] enforce ABI checking of linux DPCPP build

.ci/env/apt.sh

@@ -105,6 +105,10 @@ function install_miniforge {
     source /usr/share/miniconda/etc/profile.d/conda.sh
 }
 
+function install_abigail {
+    sudo apt-get install -y abigail-tools
+}
+
 if [ "${component}" == "dpcpp" ]; then
     add_repo
     install_dpcpp
@@ -143,6 +147,9 @@ elif [ "${component}" == "miniforge" ] ; then
         install_miniforge
     fi
     install_dev-base-conda
+elif [ "${component}" == "abigail" ] ; then
+    update
+    install_abigail
 else
     echo "Usage:"
     echo "   $0 [dpcpp|tbb|mkl|gnu-cross-compilers|clang-format|dev-base|qemu-apt|qemu-deb|llvm-version|build-sysroot|miniforge]"

.ci/scripts/abi_check.sh

@@ -0,0 +1,32 @@
+#! /bin/bash
+#===============================================================================
+# Copyright contributors to the oneDAL project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#===============================================================================
+
+ci_dir=$(dirname $(dirname $(dirname "${BASH_SOURCE[0]}")))
+cd $ci_dir
+
+# relative paths must be made from the oneDAL repo root
+main_release_dir=$1
+release_dir=$2
+
+echo Shared Library ABI Conformance
+solibs=($(ls $main_release_dir/lib*.so))
+for i in "${solibs[@]}"
+do
+    name=$(basename $i)
+    echo "--------${name}--------"
+    abidiff $i $release_dir/$name
+done

.ci/scripts/build.sh

@@ -36,6 +36,7 @@ show_help() {
 --tbb-dir:The TBB installation directory to use to build oneDAL with in the case that the backend is given as `ref`. If the installation directory does not exist, attempts to build this from source
 --use-openrng:Set this to yes if openrng is to be used as RNG backend. Use this only with the `ref` backend.
 --sysroot:The sysroot to use, in the case that clang is used as the cross-compiler
+--debug:Set build debug mode flag
 '
 }
 
@@ -76,6 +77,9 @@ while [[ $# -gt 0 ]]; do
         --use-openrng)
         use_openrng="$2"
         shift;;
+        --debug)
+        use_debug="$2"
+        shift;;
         --help)
         show_help
         exit 0
@@ -247,6 +251,10 @@ if [ "${use_openrng}" == "yes" ]; then
     make_options+=(RNG_BACKEND=openrng)
 fi
 
+if [ -n "${use_debug}" ]; then
+    make_options+=(REQDBG="${use_debug}")
+fi
+
 echo "Calling make"
 echo "CXX=$CXX"
 echo "CC=$CC"

.ci/scripts/test.sh

@@ -74,6 +74,10 @@ while [[ $# -gt 0 ]]; do
         --cross-compile)
         cross_compile="yes"
         ;;
+        --jobs)
+        jobs="$2"
+        shift
+        ;;
         --help)
         show_help_text
         exit 0
@@ -133,7 +137,9 @@ else
     exit 1
 fi
 
-if [ "$(uname)" == "Linux" ]; then
+if [[ -n "${jobs}" ]]; then
+    make_op="-j${jobs}"
+elif [ "$(uname)" == "Linux" ]; then
     make_op="-j$(nproc --all)"
 else
     make_op="-j$(sysctl -n hw.physicalcpu)"

.github/.abignore

@@ -0,0 +1,51 @@
+;
+; Copyright contributors to the oneDAL project
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+;     http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS,
+; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+; See the License for the specific language governing permissions and
+; limitations under the License.
+;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; DAAL DESELECTIONS ;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; deselect daal::internal namespace
+[suppress_type]
+  name_regexp = daal::internal::.*
+
+[suppress_variable]
+  name_regexp = daal::internal::.*
+
+[suppress_function]
+  name_regexp = daal::internal::.*
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; oneDAL DESELECTIONS ;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; deselect oneapi::dal backend namespaces
+[suppress_type]
+  name_regexp = oneapi::dal::.*backend::.*
+
+[suppress_variable]
+  name_regexp = oneapi::dal::.*backend::.*
+
+[suppress_function]
+  name_regexp = oneapi::dal::.*backend::.*
+
+; deselect oneapi::dal detail namespaces
+[suppress_type]
+  name_regexp = oneapi::dal::.*detail::.*
+
+[suppress_variable]
+  name_regexp = oneapi::dal::.*detail::.*
+
+[suppress_function]
+  name_regexp = oneapi::dal::.*detail::.*

.github/workflows/ci.yml

@@ -33,7 +33,7 @@ concurrency:
 
 jobs:
   LinuxMakeDPCPP:
-    name: LinuxMakeDPCPP
+    name: LinuxMakeDPCPP(AVX2)
     if: github.repository == 'uxlfoundation/oneDAL'
     runs-on: uxl-gpu-4xlarge
     timeout-minutes: 120
@@ -90,3 +90,47 @@ jobs:
         run: |
             source /opt/intel/oneapi/setvars.sh
             .ci/scripts/test.sh --test-kind samples --build-dir __release_lnx --compiler gnu --interface daal/cpp/mpi --conda-env ci-env --build-system cmake
+
+  LinuxABICheck:
+    name: ABI Conformance
+    needs: LinuxMakeDPCPP
+    if: |
+      github.repository == 'uxlfoundation/oneDAL' &&
+      github.event_name == 'pull_request' &&
+      ! contains(toJson(github.event.pull_request.labels.*.name), '"API/ABI breaking change"')
+    runs-on: ubuntu-24.04
+    env:
+      LIBABIGAIL_DEFAULT_USER_SUPPRESSION_FILE: ${{ github.workspace }}/.github/.abignore
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout oneDAL
+        uses: actions/checkout@v4
+      - name: install ABI checking tools
+        run: .ci/env/apt.sh abigail
+      - name: Get run ID of "CI" workflow
+        id: get-run-id
+        run: |
+          OTHER_REPO="uxlfoundation/oneDAL"
+          WF_NAME="CI"
+          JQ_QUERY='map(select(.event == "push")) | .[0].databaseId'
+          RUN_ID=`gh run --repo ${OTHER_REPO} list --workflow "${WF_NAME}" --json databaseId,event --status success --jq "${JQ_QUERY}"`
+          echo "Detected latest run id of ${RUN_ID} for workflow ${WF_NAME}"
+          echo "run-id=${RUN_ID}" >> "$GITHUB_OUTPUT"
+        env:
+          GH_TOKEN: ${{ github.token }}
+      - name: Download oneDAL main build artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: __release_lnx
+          github-token: ${{ github.token }}
+          repository: uxlfoundation/oneDAL
+          run-id: ${{ steps.get-run-id.outputs.run-id }}
+          path: ./__release_lnx_main
+      - name: Download oneDAL build artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: __release_lnx
+          path: ./__release_lnx
+      - name: Check ABI conformance
+        run: .ci/scripts/abi_check.sh __release_lnx_main/daal/latest/lib/intel64/ __release_lnx/daal/latest/lib/intel64/

INSTALL.md

@@ -155,10 +155,14 @@ It is possible to build oneDAL libraries with selected set of algorithms and/or
 
 On **Linux\*** it is possible to build debug version of oneDAL or the version that allows to do kernel profiling using <ittnotify.h>.
 
-- To build debug version of oneDAL, run:
+- To build debug version of oneDAL (including debug symbols), run:
 
             make -f makefile daal oneapi_c PLAT=lnx32e REQDBG=yes
 
+- To build oneDAL to include only symbols, run:
+
+            make -f makefile daal oneapi_c PLAT=lnx32e REQDBG=symbols
+
 - To build oneDAL with kernel profiling information, run:
 
             make -f makefile daal oneapi_c PLAT=lnx32e REQPROFILE=yes

cpp/daal/include/algorithms/algorithm_container_base_batch.h

@@ -27,6 +27,7 @@
 
 #include "services/daal_memory.h"
 #include "services/internal/daal_kernel_defines.h"
+#include "services/daal_defines.h"
 
 namespace daal
 {
@@ -154,14 +155,14 @@ class AlgorithmContainerImpl<batch> : public AlgorithmContainer<batch>
 #if defined(TARGET_X86_64)
 template <typename sse2Container DAAL_KERNEL_SSE42_ONLY(typename sse42Container) DAAL_KERNEL_AVX2_ONLY(typename avx2Container)
               DAAL_KERNEL_AVX512_ONLY(typename avx512Container)>
-class AlgorithmDispatchContainer<batch, sse2Container DAAL_KERNEL_SSE42_ONLY(sse42Container) DAAL_KERNEL_AVX2_ONLY(avx2Container)
-                                            DAAL_KERNEL_AVX512_ONLY(avx512Container)> : public AlgorithmContainerImpl<batch>
+class DAAL_EXPORT AlgorithmDispatchContainer<batch, sse2Container DAAL_KERNEL_SSE42_ONLY(sse42Container) DAAL_KERNEL_AVX2_ONLY(avx2Container)
+                                                        DAAL_KERNEL_AVX512_ONLY(avx512Container)> : public AlgorithmContainerImpl<batch>
 #elif defined(TARGET_ARM)
 template <typename SVEContainer DAAL_KERNEL_SVE_ONLY(typename sveContainer)>
-class AlgorithmDispatchContainer<batch, SVEContainer DAAL_KERNEL_SVE_ONLY(sveContainer)> : public AlgorithmContainerImpl<batch>
+class DAAL_EXPORT AlgorithmDispatchContainer<batch, SVEContainer DAAL_KERNEL_SVE_ONLY(sveContainer)> : public AlgorithmContainerImpl<batch>
 #elif defined(TARGET_RISCV64)
 template <typename RV64Container DAAL_KERNEL_RV64_ONLY(typename rv64Container)>
-class AlgorithmDispatchContainer<batch, RV64Container DAAL_KERNEL_RV64_ONLY(rv64Container)> : public AlgorithmContainerImpl<batch>
+class DAAL_EXPORT AlgorithmDispatchContainer<batch, RV64Container DAAL_KERNEL_RV64_ONLY(rv64Container)> : public AlgorithmContainerImpl<batch>
 #endif
 {
 public:

cpp/daal/include/algorithms/association_rules/apriori.h

@@ -90,15 +90,16 @@ class DAAL_EXPORT Batch : public daal::algorithms::Analysis<batch>
     typedef algorithms::association_rules::Result ResultType;
 
     /** Default constructor */
-    Batch() { initialize(); }
+    // defined elsewhere in order to prevent implicit instantation of AlgorithmBatchContainer
+    Batch();
 
     /**
      * Constructs an association rules algorithm by copying input objects and parameters
      * of another association rules algorithm
      * \param[in] other An algorithm to be used as the source to initialize the input objects
      *                  and parameters of the algorithm
      */
-    Batch(const Batch<algorithmFPType, method> & other) : input(other.input), parameter(other.parameter) { initialize(); }
+    Batch(const Batch<algorithmFPType, method> & other);
 
     /**
     * Returns method of the algorithm
@@ -143,9 +144,9 @@ class DAAL_EXPORT Batch : public daal::algorithms::Analysis<batch>
 
     void initialize()
     {
-        Analysis<batch>::_ac = new __DAAL_ALGORITHM_CONTAINER(batch, BatchContainer, algorithmFPType, method)(&_env);
-        _in                  = &input;
-        _par                 = &parameter;
+        _ac  = new __DAAL_ALGORITHM_CONTAINER(batch, BatchContainer, algorithmFPType, method)(&_env);
+        _in  = &input;
+        _par = &parameter;
         _result.reset(new ResultType());
     }
 

cpp/daal/include/algorithms/cholesky/cholesky.h

@@ -89,15 +89,15 @@ class DAAL_EXPORT Batch : public daal::algorithms::Analysis<batch>
     typedef algorithms::cholesky::Result ResultType;
 
     /** Default constructor */
-    Batch() { initialize(); }
+    Batch();
 
     /**
      * Constructs a Cholesky decomposition algorithm by copying input objects
      * of another Cholesky decomposition algorithm
      * \param[in] other An algorithm to be used as the source to initialize the input objects
      *                  and parameters of the algorithm
      */
-    Batch(const Batch<algorithmFPType, method> & other) : input(other.input) { initialize(); }
+    Batch(const Batch<algorithmFPType, method> & other);
 
     /** Destructor */
     virtual ~Batch() {}

cpp/daal/include/algorithms/classifier/binary_confusion_matrix_batch.h

@@ -94,15 +94,15 @@ class DAAL_EXPORT Batch : public daal::algorithms::quality_metric::Batch
     ParameterType parameter; /*!< Parameters of the algorithm */
 
     /** Default constructor */
-    Batch() { initialize(); }
+    Batch();
 
     /**
      * Constructs a confusion matrix algorithm by copying input objects and parameters
      * of another confusion matrix algorithm
      * \param[in] other An algorithm to be used as the source to initialize the input objects
      *                  and parameters of the algorithm
      */
-    Batch(const Batch<algorithmFPType, method> & other) : input(other.input), parameter(other.parameter) { initialize(); }
+    Batch(const Batch<algorithmFPType, method> & other);
 
     /**
      * Returns the method of the algorithm

cpp/daal/include/algorithms/classifier/multiclass_confusion_matrix_batch.h

@@ -97,15 +97,15 @@ class DAAL_EXPORT Batch : public daal::algorithms::quality_metric::Batch
      * Default constructor
      * \param[in] nClasses  Number of classes
      */
-    Batch(size_t nClasses = 2) : parameter(nClasses) { initialize(); }
+    Batch(size_t nClasses = 2);
 
     /**
      * Constructs a confusion matrix algorithm by copying input objects and parameters
      * of another confusion matrix algorithm
      * \param[in] other An algorithm to be used as the source to initialize the input objects
      *                  and parameters of the algorithm
      */
-    Batch(const Batch<algorithmFPType, method> & other) : input(other.input), parameter(other.parameter) { initialize(); }
+    Batch(const Batch<algorithmFPType, method> & other);
 
     /**
      * Returns the method of the algorithm

cpp/daal/include/algorithms/covariance/covariance_batch.h

@@ -358,7 +358,7 @@ class DAAL_EXPORT Batch : public BatchImpl
     typedef typename super::ResultType ResultType;
 
     /** Default constructor */
-    Batch() { initialize(); }
+    Batch();
 
     /**
      * Constructs an algorithm for correlation or variance-covariance matrix computation
@@ -367,7 +367,7 @@ class DAAL_EXPORT Batch : public BatchImpl
      * \param[in] other An algorithm to be used as the source to initialize the input objects
      *                  and parameters of the algorithm
      */
-    Batch(const Batch<algorithmFPType, method> & other) : BatchImpl(other) { initialize(); }
+    Batch(const Batch<algorithmFPType, method> & other);
 
     virtual ~Batch() {}
 

cpp/daal/include/algorithms/covariance/covariance_distributed.h

@@ -529,7 +529,7 @@ class DistributedIface<step2Master> : public daal::algorithms::Analysis<distribu
  *      - Result class
  */
 template <ComputeStep step, typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, Method method = defaultDense>
-class Distributed : public DistributedIface<step>
+class DAAL_EXPORT Distributed : public DistributedIface<step>
 {};
 
 /**
@@ -626,7 +626,7 @@ class Distributed<step2Master, algorithmFPType, method> : public DistributedIfac
     typedef typename super::PartialResultType PartialResultType;
 
     /** Default constructor */
-    Distributed() { initialize(); }
+    Distributed();
 
     /**
      * Constructs an algorithm for correlation or variance-covariance matrix computation
@@ -635,7 +635,7 @@ class Distributed<step2Master, algorithmFPType, method> : public DistributedIfac
      * \param[in] other An algorithm to be used as the source to initialize the input objects
      *                  and parameters of the algorithm
      */
-    Distributed(const Distributed<step2Master, algorithmFPType, method> & other) : DistributedIface<step2Master>(other) { initialize(); }
+    Distributed(const Distributed<step2Master, algorithmFPType, method> & other);
 
     virtual ~Distributed() {}