diff --git a/.flake8 b/.flake8 index 85a99eed..ed6da9ac 100644 --- a/.flake8 +++ b/.flake8 @@ -8,4 +8,5 @@ exclude = __pycache__ ./dist ./setup.py + ./dpbench/_version.py max-complexity = 10 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..bf1449b9 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 + +dpbench/_version.py export-subst diff --git a/.github/workflows/build_and_run.yml b/.github/workflows/build_and_run.yml index b271d3eb..dd229f18 100644 --- a/.github/workflows/build_and_run.yml +++ b/.github/workflows/build_and_run.yml @@ -11,17 +11,18 @@ on: env: # sycl is not included. Add it manually if you need - WORKLOADS: python,numpy,dpnp,numba_n,numba_np,numba_npr,numba_dpex_k,numba_dpex_n,numba_dpex_p,numba_mlir_k,numba_mlir_n,numba_mlir_p + # WORKLOADS: python,numpy,dpnp,numba_n,numba_np,numba_npr,numba_dpex_k,numba_dpex_n,numba_dpex_p,numba_mlir_k,numba_mlir_n,numba_mlir_p + WORKLOADS: python,numpy,dpnp,numba_n,numba_np,numba_npr,numba_dpex_k,numba_dpex_n,numba_dpex_p jobs: - build_linux: + build: name: Build and run strategy: fail-fast: false matrix: os: ["ubuntu-latest", "windows-latest"] - python: ["3.9", "3.10"] + python: ["3.9", "3.10", "3.11"] sycl: ["sycl","no-sycl"] install: ["pip", "setup.py"] include: @@ -40,6 +41,10 @@ jobs: runs-on: ${{matrix.os}} + defaults: + run: + shell: ${{ matrix.os == 'windows-latest' && 'cmd /C CALL {0}' || 'bash -el {0}' }} + steps: - name: Cancel Previous Runs uses: styfle/cancel-workflow-action@0.6.0 @@ -51,6 +56,14 @@ jobs: with: fetch-depth: 0 + # intel:numpy for python 3.11 is not upstreamed yet + - name: Patch numpy dependency for Python 3.11 + if: matrix.python == '3.11' + shell: bash -l {0} + run: | + find ./environments -type f | xargs sed -i 's/intel::numpy/numpy/' + find ./environments -type f | xargs sed -i '/numba-mlir/d' + - name: Setup miniconda uses: conda-incubator/setup-miniconda@v2 with: @@ -63,25 +76,10 @@ jobs: run-post: false - name: Conda info - shell: bash -el {0} run: | conda info conda list - - - name: Setup OpenCL CPU device - if: runner.os == 'Windows' - shell: pwsh - run: | - $script_path="$env:CONDA_PREFIX\Scripts\set-intel-ocl-icd-registry.ps1" - &$script_path - echo "OCL_ICD_FILENAMES=$env:CONDA_PREFIX\Library\lib\intelocl64.dll" >> $env:GITHUB_ENV - echo "LIB=$env:CONDA_PREFIX\Library\lib;$env:CONDA_PREFIX\compiler\lib;$env:LIB" >> $env:GITHUB_ENV - echo "INCLUDE=$env:CONDA_PREFIX\include;$env:INCLUDE" >> $env:GITHUB_ENV - # Check the variable assisting OpenCL CPU driver to find TBB DLLs which are not located where it expects them by default - $cl_cfg="$env:CONDA_PREFIX\Library\lib\cl.cfg" - Get-Content -Tail 5 -Path $cl_cfg - - name: Configure Python if: runner.os == 'Windows' shell: pwsh @@ -98,6 +96,12 @@ jobs: $env:FN="Windows-IntelLLVM.cmake" Copy-Item ".github\workflows\Windows-IntelLLVM_${env:PATCHED_CMAKE_VERSION}.cmake" "${env:PLATFORM_DIR}\${env:FN}" + # - name: Configure MSBuild + # if: runner.os == 'Windows' + # uses: ilammy/msvc-dev-cmd@v1 + # with: + # toolset: 14.35 + - name: Configure Sycl if: matrix.sycl == 'sycl' shell: bash -el {0} @@ -108,31 +112,71 @@ jobs: echo "DPBENCH_SYCL=1" >> "$GITHUB_ENV" echo "WORKLOADS=$WORKLOADS,sycl" >> "$GITHUB_ENV" + - name: Configure compiler + run: | + echo "CMAKE_GENERATOR=Ninja" >> "$GITHUB_ENV" + + - name: Configure OneAPI + run: | + echo "ONEAPI_DEVICE_SELECTOR=opencl:cpu" >> "$GITHUB_ENV" + + - name: Populate conda environment paths + shell: pwsh + if: runner.os == 'Windows' + run: | + echo "LIB=$env:CONDA_PREFIX\Library\lib;$env:CONDA_PREFIX\compiler\lib;$env:LIB" >> $env:GITHUB_ENV + echo "INCLUDE=$env:CONDA_PREFIX\include;$env:INCLUDE" >> $env:GITHUB_ENV + # echo "LIB=$CONDA_PREFIX/Library/lib;$CONDA_PREFIX/compiler/lib;$LIB" >> "$GITHUB_ENV" + # echo "INCLUDE=$CONDA_PREFIX/include;$INCLUDE" >> "$GITHUB_ENV" + - name: Build dpbench if: matrix.install == 'pip' - shell: bash -el {0} - run: | - pip install \ - --no-index --no-deps --no-build-isolation -e . -v + run: pip install --no-index --no-deps --no-build-isolation -e . -v - name: Build dpbench if: matrix.install == 'setup.py' - shell: bash -el {0} - run: | - python setup.py develop + run: python setup.py develop - - name: Run benchmarks + - name: Configure dpbench shell: bash -el {0} run: | export NUMBA_MLIR_GPU_RUNTIME=sycl # Turn off numba-dpex autofall back export NUMBA_DPEX_FALLBACK_ON_CPU=0 - # Make sure numba-dpex is using native atomics in github CI - export NUMBA_DPEX_ACTIVATE_ATOMICS_FP_NATIVE=1 - dpbench -i ${WORKLOADS} run -r2 --no-print-results || exit 1 + - name: Setup OpenCL CPU device + if: runner.os == 'Windows' + shell: pwsh + run: | + $script_path="$env:CONDA_PREFIX\Scripts\set-intel-ocl-icd-registry.ps1" + &$script_path + echo "OCL_ICD_FILENAMES=$env:CONDA_PREFIX\Library\lib\intelocl64.dll" >> $env:GITHUB_ENV + # echo "LIB=$env:CONDA_PREFIX\Library\lib;$env:CONDA_PREFIX\compiler\lib;$env:LIB" >> $env:GITHUB_ENV + # echo "INCLUDE=$env:CONDA_PREFIX\include;$env:INCLUDE" >> $env:GITHUB_ENV + # # Check the variable assisting OpenCL CPU driver to find TBB DLLs which are not located where it expects them by default + # $cl_cfg="$env:CONDA_PREFIX\Library\lib\cl.cfg" + # Get-Content -Tail 5 -Path $cl_cfg + + - name: Show auto acitvates + shell: bash -el {0} + run: ls -al $CONDA_PREFIX/etc/conda/activate.d - - name: Generate report + - name: Show OCL_ICD bash shell: bash -el {0} - run: | - dpbench -i ${WORKLOADS} report || exit 1 + run: echo $OCL_ICD_FILENAMES + + - name: Show OCL_ICD + run: echo %OCL_ICD_FILENAMES% + + # - name: List Sycl + # run: sycl-ls + + # - name: List Sycl Bash + # shell: bash -el {0} + # run: sycl-ls + + - name: Run benchmarks + run: dpbench -i ${{env.WORKLOADS}} run -r2 --no-print-results || exit 1 + + - name: Generate report + run: dpbench -i ${{env.WORKLOADS}} report || exit 1 diff --git a/.github/workflows/conda-package.yml b/.github/workflows/conda-package.yml index 9413940c..0e5c1d5c 100644 --- a/.github/workflows/conda-package.yml +++ b/.github/workflows/conda-package.yml @@ -14,7 +14,7 @@ env: PACKAGE_NAME: dpbench MODULE_NAME: dpbench # There is a separate action that removes defaults. - CHANNELS: 'dppy/label/dev,conda-forge,intel' + CHANNELS: 'dppy/label/dev,conda-forge,intel,nodefaults' VER_JSON_NAME: 'version.json' VER_SCRIPT1: "import json; f = open('version.json', 'r'); j = json.load(f); f.close(); " VER_SCRIPT2: "d = j['dpbench'][0]; print('='.join((d[s] for s in ('version', 'build'))))" @@ -26,14 +26,14 @@ jobs: strategy: fail-fast: false matrix: - python: ['3.9', '3.10'] + python: ['3.9', '3.10', '3.11'] os: [ubuntu-latest, windows-latest] runs-on: ${{ matrix.os }} defaults: run: - shell: bash -l {0} + shell: ${{ matrix.os == 'windows-latest' && 'cmd /C CALL {0}' || 'bash -l {0}' }} continue-on-error: false @@ -63,12 +63,19 @@ jobs: run: conda config --remove channels defaults - name: Store conda paths as envs + shell: bash -l {0} run: echo "CONDA_BLD=$CONDA_PREFIX/conda-bld/${{ runner.os == 'Linux' && 'linux' || 'win' }}-64/" | tr "\\" '/' >> $GITHUB_ENV # boa is an extention to conda so we can use mamba resolver in conda build - name: Install conda-build run: mamba install boa + - name: Configure MSBuild + if: runner.os == 'Windows' + uses: microsoft/setup-msbuild@v1.1 + with: + vs-version: '14.35' + - name: Build conda package run: conda mambabuild --no-test --python ${{ matrix.python }} conda-recipe diff --git a/CMakeLists.txt b/CMakeLists.txt index 2f5d28c3..d92c847b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,7 @@ # # SPDX-License-Identifier: Apache-2.0 -cmake_minimum_required(VERSION 3.22 FATAL_ERROR) +cmake_minimum_required(VERSION 3.22..3.27 FATAL_ERROR) project(dpbench LANGUAGES CXX @@ -14,10 +14,28 @@ project(dpbench set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH) +find_package(Python 3.9 REQUIRED + COMPONENTS Interpreter Development.Module) + +if(NOT DEFINED DPCTL_LIBRARY_PATH) + execute_process( + COMMAND ${Python3_EXECUTABLE} -c "import dpctl,os; print(os.path.dirname(dpctl.__file__));" + OUTPUT_VARIABLE DPCTL_LIBRARY_PATH + RESULT_VARIABLE RET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + if(RET EQUAL "1") + message(FATAL_ERROR "Module \'dpctl\' not found.") + endif() +endif() + +cmake_path(APPEND DPCTL_MODULE_PATH ${DPCTL_LIBRARY_PATH} resources cmake) +list(APPEND CMAKE_MODULE_PATH ${DPCTL_MODULE_PATH}) + find_package(pybind11 CONFIG REQUIRED) -find_package(IntelDPCPP REQUIRED) -find_package(PythonExtensions REQUIRED) -find_package(Python3 COMPONENTS NumPy Development) +find_package(IntelSYCL REQUIRED) +find_package(Dpctl REQUIRED) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED True) diff --git a/conda-recipe/bld.bat b/conda-recipe/bld.bat index 7fe45606..18912933 100644 --- a/conda-recipe/bld.bat +++ b/conda-recipe/bld.bat @@ -15,9 +15,10 @@ SET "SETUPTOOLS_USE_DISTUTILS=stdlib" SET "DPBENCH_SYCL=1" -"%PYTHON%" setup.py clean --all +@REM "%PYTHON%" setup.py clean --all set "SKBUILD_ARGS=-G Ninja -- -DCMAKE_C_COMPILER:PATH=icx -DCMAKE_CXX_COMPILER:PATH=icx" +@REM set "SKBUILD_ARGS=%SKBUILD_ARGS% -DMSVC_TOOLSET_VERSION=141" set "SKBUILD_ARGS=%SKBUILD_ARGS% -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON" FOR %%V IN (14.0.0 14 15.0.0 15 16.0.0 16 17.0.0 17) DO @( @@ -43,13 +44,13 @@ if EXIST "%PLATFORM_DIR%" ( if NOT "%WHEELS_OUTPUT_FOLDER%"=="" ( rem Install and assemble wheel package from the build bits - "%PYTHON%" setup.py install bdist_wheel %SKBUILD_ARGS% + "%PYTHON%" setup.py install bdist_wheel --single-version-externally-managed --record=record.txt %SKBUILD_ARGS% if errorlevel 1 exit 1 copy dist\dpbench*.whl %WHEELS_OUTPUT_FOLDER% if errorlevel 1 exit 1 ) ELSE ( rem Only install - "%PYTHON%" setup.py install %SKBUILD_ARGS% + "%PYTHON%" setup.py install --single-version-externally-managed --record=record.txt %SKBUILD_ARGS% if errorlevel 1 exit 1 ) diff --git a/conda-recipe/build.sh b/conda-recipe/build.sh index 1eb7e1f1..5b127a7f 100644 --- a/conda-recipe/build.sh +++ b/conda-recipe/build.sh @@ -1,32 +1,38 @@ -#!/bin/bash +#!/bin/bash -x # SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation # # SPDX-License-Identifier: Apache-2.0 # Intel LLVM must cooperate with compiler and sysroot from conda +export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:${BUILD_PREFIX}/lib" + echo "--gcc-toolchain=${BUILD_PREFIX} --sysroot=${BUILD_PREFIX}/${HOST}/sysroot -target ${HOST}" > icpx_for_conda.cfg export ICPXCFG="$(pwd)/icpx_for_conda.cfg" export ICXCFG="$(pwd)/icpx_for_conda.cfg" -export CMAKE_GENERATOR="Ninja" export DPBENCH_SYCL=1 +export CMAKE_GENERATOR="Ninja" +export CC=icx +export CXX=icpx if [ -e "_skbuild" ]; then ${PYTHON} setup.py clean --all fi -SKBUILD_ARGS="-- -DCMAKE_C_COMPILER:PATH=icx -DCMAKE_CXX_COMPILER:PATH=icpx -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON" +# declare -a ARGS=(install --single-version-externally-managed --record=record.txt) -# Build wheel package -if [ "$CONDA_PY" == "36" ]; then - WHEELS_BUILD_ARGS="-p manylinux1_x86_64" -else - WHEELS_BUILD_ARGS="-p manylinux2014_x86_64" -fi -if [ -n "${WHEELS_OUTPUT_FOLDER}" ]; then - $PYTHON setup.py install bdist_wheel ${WHEELS_BUILD_ARGS} ${SKBUILD_ARGS} - cp dist/dpnp*.whl ${WHEELS_OUTPUT_FOLDER} -else - $PYTHON setup.py install ${SKBUILD_ARGS} -fi +# if [[ -v WHEELS_OUTPUT_FOLDER ]]; then +# ARGS+=(bdist_wheel -p manylinux2014_x86_64) +# fi + +# ARGS+=(-G Ninja -- -DCMAKE_C_COMPILER:PATH=icx -DCMAKE_CXX_COMPILER:PATH=icpx -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON) + +# echo "${ARGS[*]}" + +# $PYTHON setup.py ${ARGS[@]} +$PYTHON -m pip install --no-index --no-deps --no-build-isolation . -v + +# if [[ -v WHEELS_OUTPUT_FOLDER ]]; then +# cp dist/numba_dpex*.whl "${WHEELS_OUTPUT_FOLDER[@]}" +# fi diff --git a/conda-recipe/meta.yaml b/conda-recipe/meta.yaml index 1c4394ea..44d466cb 100644 --- a/conda-recipe/meta.yaml +++ b/conda-recipe/meta.yaml @@ -4,32 +4,33 @@ package: name: dpbench - version: 0.1 + version: {{ GIT_DESCRIBE_TAG }} + source: path: .. +build: + number: {{ GIT_DESCRIBE_NUMBER }} + script_env: + - WHEELS_OUTPUT_FOLDER + requirements: build: - {{ compiler('cxx') }} - {{ compiler('dpcpp') }} >=2023.1 # [not osx] + # - conda-forge::dpcpp_win-64 # [windows] - sysroot_linux-64 >=2.28 # [linux] host: + - pip - python - setuptools - - cmake - - ninja - - wheel + - cmake==3.26* # [win] + - cmake # [not win] + - ninja # [not win] - scikit-build - cython - pybind11 - # runtime requirements, cause conda tries to install after build - # - tomli - # - alembic - # - sqlalchemy - # - py-cpuinfo - # - scipy - # - scikit-learn - # - pandas + - versioneer - intel::numpy - numba - dpctl @@ -40,11 +41,12 @@ requirements: - tomli - alembic - sqlalchemy - # - py-cpuinfo + # - versioneer + - py-cpuinfo - scipy - scikit-learn - pandas - - numpy + - intel::numpy - numba - dpctl - dpnp @@ -60,10 +62,10 @@ test: - numba-dpex - numba - numpy - imports: - - dpbench - commands: - - python -c "import dpbench" + # imports: + # - dpbench + # commands: + # - python -c "import dpbench" about: home: https://github.com/IntelPython/dpbench diff --git a/dpbench/__init__.py b/dpbench/__init__.py index 5985a8ff..10382146 100644 --- a/dpbench/__init__.py +++ b/dpbench/__init__.py @@ -1,3 +1,7 @@ # SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation # # SPDX-License-Identifier: Apache-2.0 + +from . import _version + +__version__ = _version.get_versions()["version"] diff --git a/dpbench/_version.py b/dpbench/_version.py new file mode 100644 index 00000000..840eb62e --- /dev/null +++ b/dpbench/_version.py @@ -0,0 +1,686 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 + +# This file helps to compute a version number in source trees obtained from +# git-archive tarball (such as those provided by githubs download-from-tag +# feature). Distribution tarballs (built by setup.py sdist) and build +# directories (produced by setup.py build) will contain a much shorter file +# that just contains the computed version number. + +# This file is released into the public domain. +# Generated by versioneer-0.29 +# https://github.com/python-versioneer/python-versioneer + +"""Git implementation of _version.py.""" + +import errno +import os +import re +import subprocess +import sys +from typing import Any, Callable, Dict, List, Optional, Tuple +import functools + + +def get_keywords() -> Dict[str, str]: + """Get the keywords needed to look up the version information.""" + # these strings will be replaced by git during git-archive. + # setup.py/versioneer.py will grep for the variable names, so they must + # each be defined on a line of their own. _version.py will just call + # get_keywords(). + git_refnames = "$Format:%d$" + git_full = "$Format:%H$" + git_date = "$Format:%ci$" + keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} + return keywords + + +class VersioneerConfig: + """Container for Versioneer configuration parameters.""" + + VCS: str + style: str + tag_prefix: str + parentdir_prefix: str + versionfile_source: str + verbose: bool + + +def get_config() -> VersioneerConfig: + """Create, populate and return the VersioneerConfig() object.""" + # these strings are filled in when 'setup.py versioneer' creates + # _version.py + cfg = VersioneerConfig() + cfg.VCS = "git" + cfg.style = "pep440" + cfg.tag_prefix = "" + cfg.parentdir_prefix = "" + cfg.versionfile_source = "dpbench/_version.py" + cfg.verbose = False + return cfg + + +class NotThisMethod(Exception): + """Exception raised if a method is not valid for the current scenario.""" + + +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} + + +def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator + """Create decorator to mark a method as the handler of a VCS.""" + def decorate(f: Callable) -> Callable: + """Store f in HANDLERS[vcs][method].""" + if vcs not in HANDLERS: + HANDLERS[vcs] = {} + HANDLERS[vcs][method] = f + return f + return decorate + + +def run_command( + commands: List[str], + args: List[str], + cwd: Optional[str] = None, + verbose: bool = False, + hide_stderr: bool = False, + env: Optional[Dict[str, str]] = None, +) -> Tuple[Optional[str], Optional[int]]: + """Call the given command(s).""" + assert isinstance(commands, list) + process = None + + popen_kwargs: Dict[str, Any] = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + + for command in commands: + try: + dispcmd = str([command] + args) + # remember shell=False, so use git.cmd on windows, not just git + process = subprocess.Popen([command] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None), **popen_kwargs) + break + except OSError as e: + if e.errno == errno.ENOENT: + continue + if verbose: + print("unable to run %s" % dispcmd) + print(e) + return None, None + else: + if verbose: + print("unable to find command, tried %s" % (commands,)) + return None, None + stdout = process.communicate()[0].strip().decode() + if process.returncode != 0: + if verbose: + print("unable to run %s (error)" % dispcmd) + print("stdout was %s" % stdout) + return None, process.returncode + return stdout, process.returncode + + +def versions_from_parentdir( + parentdir_prefix: str, + root: str, + verbose: bool, +) -> Dict[str, Any]: + """Try to determine the version from the parent directory name. + + Source tarballs conventionally unpack into a directory that includes both + the project name and a version string. We will also support searching up + two directory levels for an appropriately named parent directory + """ + rootdirs = [] + + for _ in range(3): + dirname = os.path.basename(root) + if dirname.startswith(parentdir_prefix): + return {"version": dirname[len(parentdir_prefix):], + "full-revisionid": None, + "dirty": False, "error": None, "date": None} + rootdirs.append(root) + root = os.path.dirname(root) # up a level + + if verbose: + print("Tried directories %s but none started with prefix %s" % + (str(rootdirs), parentdir_prefix)) + raise NotThisMethod("rootdir doesn't start with parentdir_prefix") + + +@register_vcs_handler("git", "get_keywords") +def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: + """Extract version information from the given file.""" + # the code embedded in _version.py can just fetch the value of these + # keywords. When used from setup.py, we don't want to import _version.py, + # so we do it with a regexp instead. This function is not used from + # _version.py. + keywords: Dict[str, str] = {} + try: + with open(versionfile_abs, "r") as fobj: + for line in fobj: + if line.strip().startswith("git_refnames ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["refnames"] = mo.group(1) + if line.strip().startswith("git_full ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["full"] = mo.group(1) + if line.strip().startswith("git_date ="): + mo = re.search(r'=\s*"(.*)"', line) + if mo: + keywords["date"] = mo.group(1) + except OSError: + pass + return keywords + + +@register_vcs_handler("git", "keywords") +def git_versions_from_keywords( + keywords: Dict[str, str], + tag_prefix: str, + verbose: bool, +) -> Dict[str, Any]: + """Get version information from git keywords.""" + if "refnames" not in keywords: + raise NotThisMethod("Short version file found") + date = keywords.get("date") + if date is not None: + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + + # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant + # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 + # -like" string, which we must then edit to make compliant), because + # it's been around since git-1.5.3, and it's too difficult to + # discover which version we're using, or to work around using an + # older one. + date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + refnames = keywords["refnames"].strip() + if refnames.startswith("$Format"): + if verbose: + print("keywords are unexpanded, not using") + raise NotThisMethod("unexpanded keywords, not a git-archive tarball") + refs = {r.strip() for r in refnames.strip("()").split(",")} + # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of + # just "foo-1.0". If we see a "tag: " prefix, prefer those. + TAG = "tag: " + tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} + if not tags: + # Either we're using git < 1.8.3, or there really are no tags. We use + # a heuristic: assume all version tags have a digit. The old git %d + # expansion behaves like git log --decorate=short and strips out the + # refs/heads/ and refs/tags/ prefixes that would let us distinguish + # between branches and tags. By ignoring refnames without digits, we + # filter out many common branch names like "release" and + # "stabilization", as well as "HEAD" and "master". + tags = {r for r in refs if re.search(r'\d', r)} + if verbose: + print("discarding '%s', no digits" % ",".join(refs - tags)) + if verbose: + print("likely tags: %s" % ",".join(sorted(tags))) + for ref in sorted(tags): + # sorting will prefer e.g. "2.0" over "2.0rc1" + if ref.startswith(tag_prefix): + r = ref[len(tag_prefix):] + # Filter out refs that exactly match prefix or that don't start + # with a number once the prefix is stripped (mostly a concern + # when prefix is '') + if not re.match(r'\d', r): + continue + if verbose: + print("picking %s" % r) + return {"version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": None, + "date": date} + # no suitable tags, so version is "0+unknown", but full hex is still there + if verbose: + print("no suitable tags, using unknown + full revision id") + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": "no suitable tags", "date": None} + + +@register_vcs_handler("git", "pieces_from_vcs") +def git_pieces_from_vcs( + tag_prefix: str, + root: str, + verbose: bool, + runner: Callable = run_command +) -> Dict[str, Any]: + """Get version from 'git describe' in the root of the source tree. + + This only gets called if the git-archive 'subst' keywords were *not* + expanded, and _version.py hasn't already been rewritten with a short + version string, meaning we're inside a checked out source tree. + """ + GITS = ["git"] + if sys.platform == "win32": + GITS = ["git.cmd", "git.exe"] + + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=not verbose) + if rc != 0: + if verbose: + print("Directory %s not under git control" % root) + raise NotThisMethod("'git rev-parse --git-dir' returned error") + + # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] + # if there isn't one, this yields HEX[-dirty] (no NUM) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) + # --long was added in git-1.5.5 + if describe_out is None: + raise NotThisMethod("'git describe' failed") + describe_out = describe_out.strip() + full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) + if full_out is None: + raise NotThisMethod("'git rev-parse' failed") + full_out = full_out.strip() + + pieces: Dict[str, Any] = {} + pieces["long"] = full_out + pieces["short"] = full_out[:7] # maybe improved later + pieces["error"] = None + + branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], + cwd=root) + # --abbrev-ref was added in git-1.6.3 + if rc != 0 or branch_name is None: + raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") + branch_name = branch_name.strip() + + if branch_name == "HEAD": + # If we aren't exactly on a branch, pick a branch which represents + # the current commit. If all else fails, we are on a branchless + # commit. + branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) + # --contains was added in git-1.5.4 + if rc != 0 or branches is None: + raise NotThisMethod("'git branch --contains' returned error") + branches = branches.split("\n") + + # Remove the first line if we're running detached + if "(" in branches[0]: + branches.pop(0) + + # Strip off the leading "* " from the list of branches. + branches = [branch[2:] for branch in branches] + if "master" in branches: + branch_name = "master" + elif not branches: + branch_name = None + else: + # Pick the first branch that is returned. Good or bad. + branch_name = branches[0] + + pieces["branch"] = branch_name + + # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] + # TAG might have hyphens. + git_describe = describe_out + + # look for -dirty suffix + dirty = git_describe.endswith("-dirty") + pieces["dirty"] = dirty + if dirty: + git_describe = git_describe[:git_describe.rindex("-dirty")] + + # now we have TAG-NUM-gHEX or HEX + + if "-" in git_describe: + # TAG-NUM-gHEX + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + if not mo: + # unparsable. Maybe git-describe is misbehaving? + pieces["error"] = ("unable to parse git-describe output: '%s'" + % describe_out) + return pieces + + # tag + full_tag = mo.group(1) + if not full_tag.startswith(tag_prefix): + if verbose: + fmt = "tag '%s' doesn't start with prefix '%s'" + print(fmt % (full_tag, tag_prefix)) + pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" + % (full_tag, tag_prefix)) + return pieces + pieces["closest-tag"] = full_tag[len(tag_prefix):] + + # distance: number of commits since tag + pieces["distance"] = int(mo.group(2)) + + # commit: short hex revision ID + pieces["short"] = mo.group(3) + + else: + # HEX: no tags + pieces["closest-tag"] = None + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits + + # commit date: see ISO-8601 comment in git_versions_from_keywords() + date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() + # Use only the last line. Previous lines may contain GPG signature + # information. + date = date.splitlines()[-1] + pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) + + return pieces + + +def plus_or_dot(pieces: Dict[str, Any]) -> str: + """Return a + if we don't already have one, else return a .""" + if "+" in pieces.get("closest-tag", ""): + return "." + return "+" + + +def render_pep440(pieces: Dict[str, Any]) -> str: + """Build up version string, with post-release "local version identifier". + + Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you + get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty + + Exceptions: + 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def render_pep440_branch(pieces: Dict[str, Any]) -> str: + """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . + + The ".dev0" means not master branch. Note that .dev0 sorts backwards + (a feature branch will appear "older" than the master branch). + + Exceptions: + 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0" + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces: Dict[str, Any]) -> str: + """TAG[.postN.devDISTANCE] -- No -dirty. + + Exceptions: + 1: no tags. 0.post0.devDISTANCE + """ + if pieces["closest-tag"]: + if pieces["distance"]: + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] + else: + # exception #1 + rendered = "0.post0.dev%d" % pieces["distance"] + return rendered + + +def render_pep440_post(pieces: Dict[str, Any]) -> str: + """TAG[.postDISTANCE[.dev0]+gHEX] . + + The ".dev0" means dirty. Note that .dev0 sorts backwards + (a dirty tree will appear "older" than the corresponding clean one), + but you shouldn't be releasing software with -dirty anyways. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + return rendered + + +def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: + """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . + + The ".dev0" means not master branch. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += plus_or_dot(pieces) + rendered += "g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["branch"] != "master": + rendered += ".dev0" + rendered += "+g%s" % pieces["short"] + if pieces["dirty"]: + rendered += ".dirty" + return rendered + + +def render_pep440_old(pieces: Dict[str, Any]) -> str: + """TAG[.postDISTANCE[.dev0]] . + + The ".dev0" means dirty. + + Exceptions: + 1: no tags. 0.postDISTANCE[.dev0] + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"] or pieces["dirty"]: + rendered += ".post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + else: + # exception #1 + rendered = "0.post%d" % pieces["distance"] + if pieces["dirty"]: + rendered += ".dev0" + return rendered + + +def render_git_describe(pieces: Dict[str, Any]) -> str: + """TAG[-DISTANCE-gHEX][-dirty]. + + Like 'git describe --tags --dirty --always'. + + Exceptions: + 1: no tags. HEX[-dirty] (note: no 'g' prefix) + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + if pieces["distance"]: + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) + else: + # exception #1 + rendered = pieces["short"] + if pieces["dirty"]: + rendered += "-dirty" + return rendered + + +def render_git_describe_long(pieces: Dict[str, Any]) -> str: + """TAG-DISTANCE-gHEX[-dirty]. + + Like 'git describe --tags --dirty --always -long'. + The distance/hash is unconditional. + + Exceptions: + 1: no tags. HEX[-dirty] (note: no 'g' prefix) + """ + if pieces["closest-tag"]: + rendered = pieces["closest-tag"] + rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) + else: + # exception #1 + rendered = pieces["short"] + if pieces["dirty"]: + rendered += "-dirty" + return rendered + + +def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: + """Render the given version pieces into the requested style.""" + if pieces["error"]: + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None} + + if not style or style == "default": + style = "pep440" # the default + + if style == "pep440": + rendered = render_pep440(pieces) + elif style == "pep440-branch": + rendered = render_pep440_branch(pieces) + elif style == "pep440-pre": + rendered = render_pep440_pre(pieces) + elif style == "pep440-post": + rendered = render_pep440_post(pieces) + elif style == "pep440-post-branch": + rendered = render_pep440_post_branch(pieces) + elif style == "pep440-old": + rendered = render_pep440_old(pieces) + elif style == "git-describe": + rendered = render_git_describe(pieces) + elif style == "git-describe-long": + rendered = render_git_describe_long(pieces) + else: + raise ValueError("unknown style '%s'" % style) + + return {"version": rendered, "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date")} + + +def get_versions() -> Dict[str, Any]: + """Get version information or return default if unable to do so.""" + # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have + # __file__, we can work backwards from there to the root. Some + # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which + # case we can only use expanded keywords. + + cfg = get_config() + verbose = cfg.verbose + + try: + return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, + verbose) + except NotThisMethod: + pass + + try: + root = os.path.realpath(__file__) + # versionfile_source is the relative path from the top of the source + # tree (where the .git directory might live) to this file. Invert + # this to find the root from __file__. + for _ in cfg.versionfile_source.split('/'): + root = os.path.dirname(root) + except NameError: + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to find root of source tree", + "date": None} + + try: + pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) + return render(pieces, cfg.style) + except NotThisMethod: + pass + + try: + if cfg.parentdir_prefix: + return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) + except NotThisMethod: + pass + + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", "date": None} diff --git a/dpbench/benchmarks/CMakeLists.txt b/dpbench/benchmarks/CMakeLists.txt index 6869220b..382bdd42 100644 --- a/dpbench/benchmarks/CMakeLists.txt +++ b/dpbench/benchmarks/CMakeLists.txt @@ -2,6 +2,16 @@ # # SPDX-License-Identifier: Apache-2.0 +# foreach(module_name IN LISTS black_scholes pairwise_distance) +# file(GLOB SOURCES ${module_name}/**/*.cpp) +# python_add_library(_${module_name}_sycl MODULE ${SOURCES}) +# add_sycl_to_target(TARGET _${module_name}_sycl SOURCES ${SOURCES}) +# target_include_directories(_${module_name}_sycl PRIVATE ${Dpctl_INCLUDE_DIRS}) + +# install(TARGETS _${module_name}_sycl DESTINATION ${module_name}/${module_name}_sycl_native_ext/${module_name}_sycl) +# endforeach() + + add_subdirectory(black_scholes) add_subdirectory(pairwise_distance) add_subdirectory(l2_norm) diff --git a/dpbench/benchmarks/black_scholes/black_scholes_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/black_scholes/black_scholes_sycl_native_ext/CMakeLists.txt index 0121add1..84927851 100644 --- a/dpbench/benchmarks/black_scholes/black_scholes_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/black_scholes/black_scholes_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _black_scholes_sycl) -pybind11_add_module(${py_module_name} - MODULE - black_scholes_sycl/_black_scholes_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name black_scholes_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/black_scholes_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/dbscan/dbscan_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/dbscan/dbscan_sycl_native_ext/CMakeLists.txt index 03c8ec0c..fde7959f 100644 --- a/dpbench/benchmarks/dbscan/dbscan_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/dbscan/dbscan_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _dbscan_sycl) -pybind11_add_module(${py_module_name} - MODULE - dbscan_sycl/_dbscan_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name dbscan_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/dbscan_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/gpairs/gpairs_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/gpairs/gpairs_sycl_native_ext/CMakeLists.txt index 6e3ea84d..07a22397 100644 --- a/dpbench/benchmarks/gpairs/gpairs_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/gpairs/gpairs_sycl_native_ext/CMakeLists.txt @@ -2,15 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _gpairs_sycl) -pybind11_add_module(${py_module_name} - MODULE - gpairs_sycl/_gpairs_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name gpairs_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - - DESTINATION ${py_module_dest}/gpairs_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/kmeans/kmeans_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/kmeans/kmeans_sycl_native_ext/CMakeLists.txt index e4afd3ed..3539453e 100644 --- a/dpbench/benchmarks/kmeans/kmeans_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/kmeans/kmeans_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _kmeans_sycl) -pybind11_add_module(${py_module_name} - MODULE - kmeans_sycl/_kmeans_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name kmeans_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/kmeans_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/knn/knn_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/knn/knn_sycl_native_ext/CMakeLists.txt index 8808583c..ed921150 100644 --- a/dpbench/benchmarks/knn/knn_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/knn/knn_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _knn_sycl) -pybind11_add_module(${py_module_name} - MODULE - knn_sycl/_knn_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name knn_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/knn_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/l2_norm/l2_norm_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/l2_norm/l2_norm_sycl_native_ext/CMakeLists.txt index d9fa036f..ec6c8e95 100644 --- a/dpbench/benchmarks/l2_norm/l2_norm_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/l2_norm/l2_norm_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _l2_norm_sycl) -pybind11_add_module(${py_module_name} - MODULE - l2_norm_sycl/_l2_norm_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name l2_norm_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/l2_norm_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/pairwise_distance/pairwise_distance_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/pairwise_distance/pairwise_distance_sycl_native_ext/CMakeLists.txt index 4db1bdd3..331b5a18 100644 --- a/dpbench/benchmarks/pairwise_distance/pairwise_distance_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/pairwise_distance/pairwise_distance_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _pairwise_distance_sycl) -pybind11_add_module(${py_module_name} - MODULE - pairwise_distance_sycl/_pairwise_distance_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name pairwise_distance_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/pairwise_distance_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/benchmarks/rambo/rambo_sycl_native_ext/CMakeLists.txt b/dpbench/benchmarks/rambo/rambo_sycl_native_ext/CMakeLists.txt index 0b91b1dd..fd8113da 100644 --- a/dpbench/benchmarks/rambo/rambo_sycl_native_ext/CMakeLists.txt +++ b/dpbench/benchmarks/rambo/rambo_sycl_native_ext/CMakeLists.txt @@ -2,14 +2,13 @@ # # SPDX-License-Identifier: Apache-2.0 -set(py_module_name _rambo_sycl) -pybind11_add_module(${py_module_name} - MODULE - rambo_sycl/_rambo_sycl.cpp -) -target_include_directories(${py_module_name} PUBLIC ${Dpctl_INCLUDE_DIRS}) +set(module_name rambo_sycl) +set(py_module_name _${module_name}) +python_add_library(${py_module_name} MODULE ${module_name}/${py_module_name}.cpp) +add_sycl_to_target(TARGET ${py_module_name} SOURCES ${module_name}/${py_module_name}.cpp) +target_include_directories(${py_module_name} PRIVATE ${Dpctl_INCLUDE_DIRS}) file(RELATIVE_PATH py_module_dest ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) install(TARGETS ${py_module_name} - DESTINATION ${py_module_dest}/rambo_sycl + DESTINATION ${py_module_dest}/${module_name} ) diff --git a/dpbench/configs/bench_info/npbench/__init__.py b/dpbench/configs/bench_info/npbench/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/npbench/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/__init.py b/dpbench/configs/bench_info/polybench/__init.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/__init.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/linear-algebra/__init__.py b/dpbench/configs/bench_info/polybench/linear-algebra/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/linear-algebra/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/linear-algebra/blas/__init__.py b/dpbench/configs/bench_info/polybench/linear-algebra/blas/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/linear-algebra/blas/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/linear-algebra/kernels/__init__.py b/dpbench/configs/bench_info/polybench/linear-algebra/kernels/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/linear-algebra/kernels/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/linear-algebra/solvers/__init__.py b/dpbench/configs/bench_info/polybench/linear-algebra/solvers/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/linear-algebra/solvers/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/medley/__init__.py b/dpbench/configs/bench_info/polybench/medley/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/medley/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/bench_info/polybench/stencils/__init__.py b/dpbench/configs/bench_info/polybench/stencils/__init__.py new file mode 100644 index 00000000..5985a8ff --- /dev/null +++ b/dpbench/configs/bench_info/polybench/stencils/__init__.py @@ -0,0 +1,3 @@ +# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation +# +# SPDX-License-Identifier: Apache-2.0 diff --git a/dpbench/configs/framework_info/dpcpp.toml b/dpbench/configs/framework_info/dpcpp.toml index da2a2a21..4fb50ef4 100644 --- a/dpbench/configs/framework_info/dpcpp.toml +++ b/dpbench/configs/framework_info/dpcpp.toml @@ -10,7 +10,7 @@ postfix = "dpcpp" class = "DpcppFramework" arch = "cpu" sycl_device = "cpu" -dpcpp_version = "IntelLLVM 2023.1.0" +dpcpp_version = "IntelLLVM 2023.2.0" [[framework.postfixes]] impl_postfix = "sycl" diff --git a/environments/conda-linux-sycl.yml b/environments/conda-linux-sycl.yml index 8d34ee73..eecb896f 100644 --- a/environments/conda-linux-sycl.yml +++ b/environments/conda-linux-sycl.yml @@ -16,6 +16,7 @@ dependencies: - py-cpuinfo - scipy - scikit-learn + - versioneer - pandas - intel::numpy - numba diff --git a/environments/conda-win-sycl.yml b/environments/conda-win-sycl.yml index b0cc65fa..02d937d8 100644 --- a/environments/conda-win-sycl.yml +++ b/environments/conda-win-sycl.yml @@ -16,17 +16,22 @@ dependencies: - py-cpuinfo - scipy - scikit-learn + - versioneer - pandas - intel::numpy - numba - dpctl - dpnp - numba-dpex - - numba-mlir - - dpcpp_win-64 - - cmake + # - numba-mlir + # - conda-forge::dpcpp_win-64 + - intel::dpcpp_win-64 + # fixing cmake version here, because we need to apply patch for IntelLLVM + - cmake==3.26* - cython - scikit-build + # set's OpenCL runtime (better version of intel-opencl-rt) + # - khronos-opencl-icd-loader - intel::intel-opencl-rt # need for set-intel-ocl-icd-registry.ps1 # https://github.com/scikit-build/scikit-build/issues/981 - setuptools>=42,<64 diff --git a/environments/conda.yml b/environments/conda.yml index cfafd23b..52be1fce 100644 --- a/environments/conda.yml +++ b/environments/conda.yml @@ -16,6 +16,7 @@ dependencies: - py-cpuinfo - scipy - scikit-learn + - versioneer - pandas - intel::intel-opencl-rt # need for set-intel-ocl-icd-registry.ps1 - intel::numpy diff --git a/pyproject.toml b/pyproject.toml index 4b666924..1f66b358 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,7 +17,6 @@ skip = ["versioneer.py", "dpbench/_version.py"] [project] name = "dpbench" -version = "0.0.1" authors = [{ name = "Intel Corp." }, { email = "diptorup.deb@intel.com" }] description = "dpBench" classifiers = [ @@ -27,7 +26,7 @@ classifiers = [ ] # https://github.com/pypa/pip/issues/6677 license = { text = "Apache-2.0" } -requires-python = ">=3.9" # TODO: lower it to 3.8 +requires-python = ">=3.9" dependencies = [ "tomli", "alembic>=1.10.0", @@ -42,6 +41,7 @@ dependencies = [ "numba", "numba_dpex", ] +dynamic =["version" ] [project.optional-dependencies] numba-mlir = ["numba_mlir"] @@ -61,5 +61,14 @@ dpbench = "dpbench.console.entry:main" [build-system] # TODO: make it optional for no sycl build. Workaround: `--no-deps`. # https://github.com/scikit-build/scikit-build/issues/981 -requires = ["setuptools>=42,<64"] +requires = [ + "setuptools>=42,<64", + "versioneer", +] build-backend = "setuptools.build_meta" + +[tool.versioneer] +VCS = "git" +style = "pep440" +versionfile_source = "dpbench/_version.py" +parentdir_prefix = "" diff --git a/setup.py b/setup.py index 02877d12..e22649c7 100644 --- a/setup.py +++ b/setup.py @@ -6,6 +6,7 @@ import os +import versioneer from setuptools import find_packages if not os.getenv("DPBENCH_SYCL"): @@ -13,29 +14,26 @@ cmake_args = None else: - import dpctl - import pybind11 from skbuild import setup + from skbuild.platform_specifics import windows - pybind11_cmake_dir = pybind11.get_cmake_dir() - dpctl_include_dir = dpctl.get_include() - dpctl_cmake_dir = ( - dpctl_include_dir.removesuffix("/include") + "/resource/cmake" - ) - cmake_args = [ - "-Dpybind11_DIR=" + pybind11_cmake_dir, - "-DDpctl_INCLUDE_DIRS=" + dpctl_include_dir, - "-DDPCTL_MODULE_PATH=" + dpctl_cmake_dir, - ] + cmake_args = ["-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON"] + # Monkey patch msvc compiler environment, so scikit-build does not overwrite + # it. Make sure to set desired environment using: + # > vcvars64.bat -vcvars_ver= + windows._get_msvc_compiler_env = lambda v, t: windows.CachedEnv() setup( # https://github.com/pypa/packaging-problems/issues/606 + name="dpbench", url="https://github.com/IntelPython/dpbench", packages=( find_packages(include=["*"]) + find_packages(where="./dpbench/benchmarks/*/*") ), + version=versioneer.get_version(), + cmdclass=versioneer.get_cmdclass(), include_package_data=True, package_data={ "dpbench.migrations": ["alembic.ini"],