# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.

#

# 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.

from __future__ import annotations

import ctypes

import errno

import fnmatch

import glob

import multiprocessing

import os

import platform

import re

import shlex

import shutil

import subprocess

import sys

import time

from contextlib import contextmanager

from pathlib import Path

from subprocess import CalledProcessError

from setuptools import Command, Extension, setup

from setuptools.command.develop import develop as DevelopCommandBase

from setuptools.command.egg_info import egg_info

from setuptools.command.install import install as InstallCommandBase

from setuptools.command.install_lib import install_lib

from setuptools.dist import Distribution

python_version = platform.python_version()

version_detail = sys.version_info

version = str(version_detail[0]) + '.' + str(version_detail[1])

env_version = os.getenv("PY_VERSION", None)

if version_detail < (3, 8):

raise RuntimeError(

f"Paddle only supports Python version >= 3.8 now,"

f"you are using Python {python_version}"

)

elif env_version is None:

print(f"export PY_VERSION = { version }")

os.environ["PY_VERSION"] = python_version

elif env_version != version:

raise ValueError(

f"You have set the PY_VERSION environment variable to {env_version}, but "

f"your current Python version is {version}, "

f"Please keep them consistent."

)

# check cmake

CMAKE = shutil.which('cmake3') or shutil.which('cmake')

assert (

CMAKE

), 'The "cmake" executable is not found. Please check if Cmake is installed.'

TOP_DIR = os.path.dirname(os.path.realpath(__file__))

IS_WINDOWS = os.name == 'nt'

def filter_setup_args(input_args):

cmake_and_build = True

only_cmake = False

rerun_cmake = False

filter_args_list = []

for arg in input_args:

if arg == 'rerun-cmake':

rerun_cmake = True # delete CMakeCache.txt and rerun cmake

continue

if arg == 'only-cmake':

only_cmake = True # only cmake and do not make, leave a chance for users to adjust build options

continue

if arg in ['clean', 'egg_info', 'sdist']:

cmake_and_build = False

filter_args_list.append(arg)

return cmake_and_build, only_cmake, rerun_cmake, filter_args_list

cmake_and_build, only_cmake, rerun_cmake, filter_args_list = filter_setup_args(

sys.argv

)

def parse_input_command(input_parameters):

dist = Distribution()

# get script name :setup.py

sys.argv = input_parameters

dist.script_name = os.path.basename(sys.argv[0])

# get args of setup.py

dist.script_args = sys.argv[1:]

print(

"Start executing python {} {}".format(

dist.script_name, "".join(dist.script_args)

)

)

try:

dist.parse_command_line()

except:

print(

f"An error occurred while parsing"

f"the parameters, {dist.script_args}"

)

sys.exit(1)

class BinaryDistribution(Distribution):

def has_ext_modules(foo):

return True

RC = 0

ext_suffix = (

'.dll'

if os.name == 'nt'

else ('.dylib' if sys.platform == 'darwin' else '.so')

)

def get_header_install_dir(header):

if 'pb.h' in header or 'pd_op.h' in header:

install_dir = re.sub(

env_dict.get("PADDLE_BINARY_DIR") + '/', '', header, count=1

)

elif 'third_party' not in header:

# paddle headers

install_dir = re.sub(

env_dict.get("PADDLE_SOURCE_DIR") + '/', '', header, count=1

)

if 'fluid/jit' in install_dir:

install_dir = re.sub('fluid/jit', 'jit', install_dir, count=1)

else:

# third_party

install_dir = re.sub(

env_dict.get("THIRD_PARTY_PATH"), 'third_party', header, count=1

)

patterns = [

'install/mkldnn/include/',

'pybind/src/extern_pybind/include/',

'third_party/xpu/src/extern_xpu/xpu/include/',

]

for pattern in patterns:

install_dir = re.sub(pattern, '', install_dir, count=1)

return install_dir

class InstallHeaders(Command):

"""Override how headers are copied."""

description = 'install C/C++ header files'

user_options = [

('install-dir=', 'd', 'directory to install header files to'),

('force', 'f', 'force installation (overwrite existing files)'),

]

boolean_options = ['force']

def initialize_options(self):

self.install_dir = None

self.force = 0

self.outfiles = []

def finalize_options(self):

self.set_undefined_options(

'install', ('install_headers', 'install_dir'), ('force', 'force')

)

def run(self):

hdrs = self.distribution.headers

if not hdrs:

return

self.mkpath(self.install_dir)

for header in hdrs:

install_dir = get_header_install_dir(header)

install_dir = os.path.join(

self.install_dir, os.path.dirname(install_dir)

)

if not os.path.exists(install_dir):

self.mkpath(install_dir)

(out, _) = self.copy_file(header, install_dir)

self.outfiles.append(out)

# (out, _) = self.mkdir_and_copy_file(header)

# self.outfiles.append(out)

def get_inputs(self):

return self.distribution.headers or []

def get_outputs(self):

return self.outfiles

class InstallCommand(InstallCommandBase):

def finalize_options(self):

ret = InstallCommandBase.finalize_options(self)

self.install_lib = self.install_platlib

self.install_headers = os.path.join(

self.install_platlib, 'paddle', 'include'

)

return ret

class DevelopCommand(DevelopCommandBase):

def run(self):

# copy proto and .so to python_source_dir

fluid_proto_binary_path = (

paddle_binary_dir + '/python/paddle/base/proto/'

)

fluid_proto_source_path = (

paddle_source_dir + '/python/paddle/base/proto/'

)

distributed_proto_binary_path = (

paddle_binary_dir + '/python/paddle/distributed/fleet/proto/'

)

distributed_proto_source_path = (

paddle_source_dir + '/python/paddle/distributed/fleet/proto/'

)

os.system(f"rm -rf {fluid_proto_source_path}")

shutil.copytree(fluid_proto_binary_path, fluid_proto_source_path)

os.system(f"rm -rf {distributed_proto_source_path}")

shutil.copytree(

distributed_proto_binary_path, distributed_proto_source_path

)

shutil.copy(

paddle_binary_dir + '/python/paddle/base/libpaddle.so',

paddle_source_dir + '/python/paddle/base/',

)

dynamic_library_binary_path = paddle_binary_dir + '/python/paddle/libs/'

dynamic_library_source_path = paddle_source_dir + '/python/paddle/libs/'

for lib_so in os.listdir(dynamic_library_binary_path):

shutil.copy(

dynamic_library_binary_path + lib_so,

dynamic_library_source_path,

)

# write version.py and cuda_env_config_py to python_source_dir

write_version_py(

filename=f'{paddle_source_dir}/python/paddle/version/__init__.py'

)

write_cuda_env_config_py(

filename=f'{paddle_source_dir}/python/paddle/cuda_env.py'

)

write_parameter_server_version_py(

filename=f'{paddle_source_dir}/python/paddle/incubate/distributed/fleet/parameter_server/version.py'

)

DevelopCommandBase.run(self)

class EggInfo(egg_info):

"""Copy license file into `.dist-info` folder."""

def run(self):

# don't duplicate license into `.dist-info` when building a distribution

if not self.distribution.have_run.get('install', True):

self.mkpath(self.egg_info)

self.copy_file(

env_dict.get("PADDLE_SOURCE_DIR") + "/LICENSE", self.egg_info

)

egg_info.run(self)

# class Installlib is rewritten to add header files to .egg/paddle

class InstallLib(install_lib):

def run(self):

self.build()

outfiles = self.install()

hrds = self.distribution.headers

if not hrds:

return

for header in hrds:

install_dir = get_header_install_dir(header)

install_dir = os.path.join(

self.install_dir, 'paddle/include', os.path.dirname(install_dir)

)

if not os.path.exists(install_dir):

self.mkpath(install_dir)

self.copy_file(header, install_dir)

if outfiles is not None:

# always compile, in case we have any extension stubs to deal with

self.byte_compile(outfiles)

def git_commit() -> str:

try:

cmd = ['git', 'rev-parse', 'HEAD']

git_commit = (

subprocess.Popen(

cmd,

stdout=subprocess.PIPE,

cwd=env_dict.get("PADDLE_SOURCE_DIR"),

)

.communicate()[0]

.strip()

)

except:

git_commit = 'Unknown'

git_commit = git_commit.decode('utf-8')

return str(git_commit)

def _get_version_detail(idx):

assert (

idx < 3

), "version info consists of %(major)d.%(minor)d.%(patch)d, \

so detail index must less than 3"

tag_version_regex = env_dict.get("TAG_VERSION_REGEX")

paddle_version = env_dict.get("PADDLE_VERSION")

if re.match(tag_version_regex, paddle_version):

version_details = paddle_version.split('.')

if len(version_details) >= 3:

return version_details[idx]

return 0

def _mkdir_p(dir_str):

try:

os.makedirs(dir_str)

except OSError as e:

raise RuntimeError("Failed to create build folder")

def get_major() -> int:

return int(_get_version_detail(0))

def get_minor() -> int:

return int(_get_version_detail(1))

def get_patch() -> int:

return str(_get_version_detail(2))

def get_nccl_version() -> int:

if env_dict.get("WITH_NCCL") == 'ON':

return int(env_dict.get("NCCL_VERSION"))

return 0

def get_cuda_version() -> str:

with_gpu = env_dict.get("WITH_GPU")

if with_gpu == 'ON':

return env_dict.get("CUDA_VERSION")

else:

return 'False'

def get_cudnn_version() -> str:

with_gpu = env_dict.get("WITH_GPU")

if with_gpu == 'ON':

temp_cudnn_version = ''

cudnn_major_version = env_dict.get("CUDNN_MAJOR_VERSION")

if cudnn_major_version:

temp_cudnn_version += cudnn_major_version

cudnn_minor_version = env_dict.get("CUDNN_MINOR_VERSION")

if cudnn_minor_version:

temp_cudnn_version = (

temp_cudnn_version + '.' + cudnn_minor_version

)

cudnn_patchlevel_version = env_dict.get(

"CUDNN_PATCHLEVEL_VERSION"

)

if cudnn_patchlevel_version:

temp_cudnn_version = (

temp_cudnn_version + '.' + cudnn_patchlevel_version

)

return temp_cudnn_version

else:

return 'False'

def get_xpu_xre_version() -> str:

with_xpu = env_dict.get("WITH_XPU")

if with_xpu == 'ON':

return env_dict.get("XPU_XRE_BASE_VERSION")

else:

return 'False'

def get_xpu_xccl_version() -> str:

with_xpu_xccl = env_dict.get("WITH_XPU_BKCL")

if with_xpu_xccl == 'ON':

return env_dict.get("XPU_XCCL_BASE_VERSION")

else:

return 'False'

def get_xpu_xhpc_version() -> str:

with_xpu_xhpc = env_dict.get("WITH_XPU")

if with_xpu_xhpc == 'ON':

return env_dict.get("XPU_XHPC_BASE_DATE")

else:

return 'False'

def is_tagged() -> bool:

try:

cmd = [

'git',

'describe',

'--exact-match',

'--tags',

'HEAD',

'2>/dev/null',

]

git_tag = (

subprocess.Popen(

cmd,

stdout=subprocess.PIPE,

cwd=env_dict.get("PADDLE_SOURCE_DIR"),

)

.communicate()[0]

.strip()

)

git_tag = git_tag.decode()

except:

return False

if str(git_tag).replace('v', '') == env_dict.get("PADDLE_VERSION"):

return True

else:

return False

def get_cinn_version() -> str:

if env_dict.get("WITH_CINN") != 'ON':

return "False"

return "0.3.0"

def get_cuda_archs() -> list[int]:

compiled_cuda_archs = env_dict.get("COMPILED_CUDA_ARCHS")

if isinstance(compiled_cuda_archs, str):

compiled_cuda_archs = re.findall(r'\d+', compiled_cuda_archs)

return [int(arch) for arch in compiled_cuda_archs]

else:

return []

def get_tensorrt_version() -> str:

def find_libnvinfer():

"""Search for libnvinfer.so file in LD_LIBRARY_PATH."""

trt_infer_rt_path = env_dict.get("TR_INFER_RT")

tensorrt_library_path = env_dict.get("TENSORRT_LIBRARY_DIR")

libnvinfer_file = os.path.join(tensorrt_library_path, trt_infer_rt_path)

if os.path.exists(libnvinfer_file):

return libnvinfer_file

else:

print(f"{libnvinfer_file} not found.")

return None

try:

libnvinfer_path = find_libnvinfer()

if not libnvinfer_path:

return None

trt = ctypes.CDLL(libnvinfer_path)

get_version = trt.getInferLibVersion

get_version.restype = ctypes.c_int

version = get_version()

version_str = str(version)

major = version_str[:1] if len(version_str) > 1 else version_str

minor = version_str[1:2] if len(version_str) > 3 else version_str[1:]

patch = version_str[3:] if len(version_str) > 3 else ''

minor = minor if minor else '0'

patch = patch if patch else '0'

version_str = f"{major}.{minor}.{patch}"

return version_str

except Exception as e:

print(f"Error while getting TensorRT version: {e}")

return None

def write_version_py(filename='paddle/version/__init__.py'):

cnt = '''# THIS FILE IS GENERATED FROM PADDLEPADDLE SETUP.PY

#

full_version = '%(major)d.%(minor)d.%(patch)s'

major = '%(major)d'

minor = '%(minor)d'

patch = '%(patch)s'

nccl_version = '%(nccl)d'

rc = '%(rc)d'

cuda_version = '%(cuda)s'

cudnn_version = '%(cudnn)s'

xpu_xre_version = '%(xpu_xre)s'

xpu_xccl_version = '%(xpu_xccl)s'

xpu_xhpc_version = '%(xpu_xhpc)s'

is_tagged = %(is_tagged)s

commit = '%(commit)s'

with_mkl = '%(with_mkl)s'

cinn_version = '%(cinn)s'

tensorrt_version = '%(tensorrt)s'

with_pip_cuda_libraries = '%(with_pip_cuda_libraries)s'

with_pip_tensorrt = '%(with_pip_tensorrt)s'

compiled_cuda_archs = %(compiled_cuda_archs)s

__all__ = ['cuda', 'cudnn', 'nccl', 'show', 'xpu', 'xpu_xre', 'xpu_xccl', 'xpu_xhpc', 'tensorrt', 'cuda_archs']

def show() -> None:

"""Get the version of paddle if `paddle` package if tagged. Otherwise, output the corresponding commit id.

Returns:

If paddle package is not tagged, the commit-id of paddle will be output.

Otherwise, the following information will be output.

full_version: version of paddle

major: the major version of paddle

minor: the minor version of paddle

patch: the patch level version of paddle

rc: whether it's rc version

cuda: the cuda version of package. It will return `False` if CPU version paddle package is installed

cudnn: the cudnn version of package. It will return `False` if CPU version paddle package is installed

xpu_xre: the xpu xre version of package. It will return `False` if non-XPU version paddle package is installed

xpu_xccl: the xpu xccl version of package. It will return `False` if non-XPU version paddle package is installed

xpu_xhpc: the xpu xhpc version of package. It will return `False` if non-XPU version paddle package is installed

cinn: the cinn version of package. It will return `False` if paddle package is not compiled with CINN

Examples:

.. code-block:: python

>>> import paddle

>>> # Case 1: paddle is tagged with 2.2.0

>>> paddle.version.show()

>>> # doctest: +SKIP('Different environments yield different output.')

full_version: 2.2.0

major: 2

minor: 2

patch: 0

rc: 0

cuda: '10.2'

cudnn: '7.6.5'

xpu_xre: '4.32.0.1'

xpu_xccl: '1.0.7'

xpu_xhpc: '20231208'

cinn: False

>>> # doctest: -SKIP

>>> # Case 2: paddle is not tagged

>>> paddle.version.show()

>>> # doctest: +SKIP('Different environments yield different output.')

commit: cfa357e984bfd2ffa16820e354020529df434f7d

cuda: '10.2'

cudnn: '7.6.5'

xpu_xre: '4.32.0.1'

xpu_xccl: '1.0.7'

xpu_xhpc: '20231208'

cinn: False

>>> # doctest: -SKIP

"""

if is_tagged:

print('full_version:', full_version)

print('major:', major)

print('minor:', minor)

print('patch:', patch)

print('rc:', rc)

else:

print('commit:', commit)

print('cuda:', cuda_version)

print('cudnn:', cudnn_version)

print('nccl:', nccl_version)

print('xpu_xre:', xpu_xre_version)

print('xpu_xccl:', xpu_xccl_version)

print('xpu_xhpc:', xpu_xhpc_version)

print('cinn:', cinn_version)

print('tensorrt_version:', tensorrt_version)

print('cuda_archs:', compiled_cuda_archs)

def mkl() -> str:

return with_mkl

def nccl() -> str:

"""Get nccl version of paddle package.

Returns:

string: Return the version information of cuda nccl. If paddle package is CPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.nccl()

>>> # doctest: +SKIP('Different environments yield different output.')

'2804'

"""

return nccl_version

def cuda() -> str:

"""Get cuda version of paddle package.

Returns:

string: Return the version information of cuda. If paddle package is CPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.cuda()

>>> # doctest: +SKIP('Different environments yield different output.')

'10.2'

"""

return cuda_version

def cudnn() -> str:

"""Get cudnn version of paddle package.

Returns:

string: Return the version information of cudnn. If paddle package is CPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.cudnn()

>>> # doctest: +SKIP('Different environments yield different output.')

'7.6.5'

"""

return cudnn_version

def xpu() -> str:

"""Get xpu version of paddle package. The API is deprecated now, please use xpu_xhpc() instead.

Returns:

string: Return the version information of xpu. If paddle package is non-XPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.xpu()

>>> # doctest: +SKIP('Different environments yield different output.')

'20230114'

"""

return xpu_xhpc_version

def xpu_xre() -> str:

"""Get xpu xre version of paddle package.

Returns:

string: Return the version information of xpu. If paddle package is non-XPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.xpu_xre()

>>> # doctest: +SKIP('Different environments yield different output.')

'4.32.0.1'

"""

return xpu_xre_version

def xpu_xccl() -> str:

"""Get xpu xccl version of paddle package.

Returns:

string: Return the version information of xpu xccl. If paddle package is non-XPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.xpu_xccl()

>>> # doctest: +SKIP('Different environments yield different output.')

'1.0.7'

"""

return xpu_xccl_version

def xpu_xhpc() -> str:

"""Get xpu xhpc version of paddle package.

Returns:

string: Return the version information of xpu xhpc. If paddle package is non-XPU version, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.xpu_xhpc()

>>> # doctest: +SKIP('Different environments yield different output.')

'20231208'

"""

return xpu_xhpc_version

def cinn() -> str:

"""Get CINN version of paddle package.

Returns:

string: Return the version information of CINN. If paddle package is not compiled with CINN, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.cinn()

>>> # doctest: +SKIP('Different environments yield different output.')

False

"""

return cinn_version

def tensorrt() -> str:

"""Get TensorRT version of paddle package.

Returns:

string: Return the version information of TensorRT. If paddle package is not compiled with TensorRT, it will return False.

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.tensorrt()

>>> # doctest: +SKIP('Different environments yield different output.')

False

"""

return tensorrt_version

def cuda_archs():

"""Get compiled cuda archs of paddle package.

Returns:

list[int]: Return the compiled cuda archs if with gpu. If paddle package is not compiled with gpu, it will return "".

Examples:

.. code-block:: python

>>> import paddle

>>> paddle.version.cuda_archs()

>>> # doctest: +SKIP('Different environments yield different output.')

[86]

"""

return compiled_cuda_archs

'''

commit = git_commit()

dirname = os.path.dirname(filename)

try:

os.makedirs(dirname)

except OSError as e:

if e.errno != errno.EEXIST:

raise

with open(filename, 'w') as f:

f.write(

cnt

% {

'major': get_major(),

'minor': get_minor(),

'patch': get_patch(),

'nccl': get_nccl_version(),

'rc': RC,

'version': env_dict.get("PADDLE_VERSION"),

'cuda': get_cuda_version(),

'cudnn': get_cudnn_version(),

'xpu_xre': get_xpu_xre_version(),

'xpu_xccl': get_xpu_xccl_version(),

'xpu_xhpc': get_xpu_xhpc_version(),

'commit': commit,

'is_tagged': is_tagged(),

'with_mkl': env_dict.get("WITH_MKL"),

'cinn': get_cinn_version(),

'tensorrt': get_tensorrt_version(),

'with_pip_cuda_libraries': env_dict.get(

"WITH_PIP_CUDA_LIBRARIES"

),

'with_pip_tensorrt': env_dict.get("WITH_PIP_TENSORRT"),

'compiled_cuda_archs': get_cuda_archs(),

}

)

def write_cuda_env_config_py(filename='paddle/cuda_env.py'):

cnt = ""

if env_dict.get("JIT_RELEASE_WHL") == 'ON':

cnt = '''# THIS FILE IS GENERATED FROM PADDLEPADDLE SETUP.PY

#

import os

os.environ['CUDA_CACHE_MAXSIZE'] = '805306368'

'''

with open(filename, 'w') as f:

f.write(cnt)

def write_parameter_server_version_py(

filename='paddle/incubate/distributed/fleet/parameter_server/version.py',

):

cnt = '''

# THIS FILE IS GENERATED FROM PADDLEPADDLE SETUP.PY

from paddle.incubate.distributed.fleet.base import Mode

BUILD_MODE=Mode.%(mode)s

def is_transpiler():

return Mode.TRANSPILER == BUILD_MODE

'''

dirname = os.path.dirname(filename)

try:

os.makedirs(dirname)

except OSError as e:

if e.errno != errno.EEXIST:

raise

with open(filename, 'w') as f:

f.write(

cnt

% {

'mode': (

'PSLIB'

if env_dict.get("WITH_PSLIB") == 'ON'

else 'TRANSPILER'

)

}

)

def find_files(pattern, root, recursive=False):

for dirpath, _, files in os.walk(root):

for filename in fnmatch.filter(files, pattern):

yield os.path.join(dirpath, filename)

if not recursive:

break

@contextmanager

def cd(path):

if not os.path.isabs(path):

raise RuntimeError(f'Can only cd to absolute path, got: {path}')

orig_path = os.getcwd()

os.chdir(path)

try:

yield

finally:

os.chdir(orig_path)

def options_process(args, build_options):

for key, value in sorted(build_options.items()):

if value is not None:

args.append(f"-D{key}={value}")

def get_cmake_generator():

if os.getenv("GENERATOR"):

cmake_generator = os.getenv("GENERATOR")

if os.system('ninja --version') == 0:

print("Ninja has been installed,use ninja to compile Paddle now.")

else:

print("Ninja has not been installed,install it now.")

os.system('python -m pip install ninja')

else:

cmake_generator = "Unix Makefiles"

return cmake_generator

def cmake_run(build_path):

args = []

env_var = os.environ.copy() # get env variables

paddle_build_options = {}

other_options = {}

other_options.update(

{

option: option

for option in (

"PYTHON_LIBRARY",

"INFERENCE_DEMO_INSTALL_DIR",

"ON_INFER",

"PYTHON_EXECUTABLE",

"TENSORRT_ROOT",

"CUDA_ARCH_NAME",

"CUDA_ARCH_BIN",

"PYTHON_INCLUDE_DIR",

"PYTHON_LIBRARIES",

"PY_VERSION",

"CUB_PATH",

"NEW_RELEASE_PYPI",

"CUDNN_ROOT",

"THIRD_PARTY_PATH",

"NOAVX_CORE_FILE",

"LITE_GIT_TAG",

"CUDA_TOOLKIT_ROOT_DIR",

"NEW_RELEASE_JIT",

"XPU_SDK_ROOT",

"MSVC_STATIC_CRT",

"NEW_RELEASE_ALL",

"GENERATOR",

)

}

)

# if environment variables which start with "WITH_" or "CMAKE_",put it into build_options

for option_key, option_value in env_var.items():

if option_key.startswith(("CMAKE_", "WITH_")):

paddle_build_options[option_key] = option_value

if option_key in other_options:

if (

option_key == 'PYTHON_EXECUTABLE'

or option_key == 'PYTHON_LIBRARY'

or option_key == 'PYTHON_LIBRARIES'

):

key = option_key + ":FILEPATH"

elif option_key == 'PYTHON_INCLUDE_DIR':

key = option_key + ':PATH'

elif option_key == 'GENERATOR':

key = 'CMAKE_' + option_key

else:

key = other_options[option_key]

if key not in paddle_build_options:

paddle_build_options[key] = option_value

options_process(args, paddle_build_options)

with cd(build_path):

cmake_args = []

cmake_args.append(CMAKE)

cmake_args += args

cmake_args.append('-DWITH_SETUP_INSTALL=ON')

cmake_args.append(TOP_DIR)

subprocess.check_call(cmake_args)

def build_run(args, build_path, environ_var):

with cd(build_path):

build_args = []

build_args.append(CMAKE)

build_args += args

try:

subprocess.check_call(build_args, cwd=build_path, env=environ_var)

except (CalledProcessError, KeyboardInterrupt) as e:

sys.exit(1)

def run_cmake_build(build_path):

build_type = (

os.getenv("CMAKE_BUILD_TYPE")

if os.getenv("CMAKE_BUILD_TYPE") is not None

else "release"

)

build_args = ["--build", ".", "--target", "install", "--config", build_type]

max_jobs = os.getenv("MAX_JOBS")

if max_jobs is not None:

max_jobs = max_jobs or str(multiprocessing.cpu_count())

build_args += ["--"]

if IS_WINDOWS:

build_args += [f"/p:CL_MPCount={max_jobs}"]

else:

build_args += ["-j", max_jobs]

else:

build_args += ["-j", str(multiprocessing.cpu_count())]

environ_var = os.environ.copy()

build_run(build_args, build_path, environ_var)