blob: 4e9a644521d4a792e505e1c36b054cae76195316 [file] [log] [blame]
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
'''Script for building wheel package for installing singa via pip.
This script must be launched at the root dir of the singa project
inside the docker container created via tool/docker/devel/centos/cudaxx/Dockerfile.manylinux2014.
# launch docker container
$ nvidia-docker run -v <local singa dir>:/root/singa -it apache/singa:manylinux2014-cuda10.2
# build the wheel packag; replace cp36-cp36m to compile singa for other py version
$ /opt/python/cp36-cp36m/bin/python bdist_wheel
$ /opt/python/cp37-cp37m/bin/python bdist_wheel
$ /opt/python/cp38-cp38/bin/python bdist_wheel
The generted wheel file should be repaired by the auditwheel tool to make it
compatible with PEP513. Otherwise, the dependent libs will not be included in
the wheel package and the wheel file will be rejected by PYPI website during
uploading due to file name error.
# repair the wheel pakage and upload to pypi
$ /opt/python/cp36-cp36m/bin/python audit
For the Dockerfile with CUDA and CUDNN installed, the CUDA version and
CUDNN version are exported as environment variable: CUDA_VERSION, CUDNN_VERSION.
You can control the script to build CUDA enabled singa package by exporting
SINGA_CUDA=ON; otherwise the CPU only package will be built.
from setuptools import find_packages, setup, Command, Extension
from setuptools.command.build_ext import build_ext
from distutils.errors import CompileError, DistutilsSetupError
import os
import io
import sys
import subprocess
import shutil
import shlex
from pathlib import Path
import numpy as np
NAME = 'singa'
Pypi does not allow you to overwrite the uploaded package;
therefore, you have to bump the version.
Pypi does not allow [local version label](
to appear in the version, therefore, you have to include the public
version label only. Currently, due to the pypi size limit, the package
uploaded to pypi is cpu only (without cuda and cudnn), which can be installed via
$ pip install singa
$ pip install singa=3.0.0.dev1
The cuda and cudnn enabled package's version consists of the public
version label + local version label, e.g., 3.0.0.dev1+cuda10.2, which
can be installed via
$ pip install singa=3.0.0.dev1+cuda10.2 -f <url of the repo>
from datetime import date
# stable version
VERSION = '3.2.0'
# get the git hash
# git_hash = subprocess.check_output(["git", "describe"]).strip().split('-')[-1][1:]
# comment the next line to build wheel for stable version
# VERSION += '.dev' +'%y%m%d')
SINGA_PY = Path('python')
SINGA_SRC = Path('src')
SINGA_HDR = Path('include')
class AuditCommand(Command):
"""Support upload."""
description = 'Repair the package via auditwheel tool.'
user_options = []
def status(s):
"""Prints things in bold."""
def initialize_options(self):
def finalize_options(self):
def run(self):
self.status('Removing previous wheel files under wheelhouse')
shutil.rmtree('wheelhouse', ignore_errors=True)
for wheel in os.listdir('dist'):
self.status('Repair the dist/{} via auditwheel'.format(wheel))
os.system('auditwheel repair dist/{}'.format(wheel))
# self.status('Uploading the package to PyPI via Twine…')
# os.system('{} -m twine upload dist/*'.format(sys.executable))
def parse_compile_options():
'''Read the environment variables to parse the compile options.
a tuple of bool values as the indicators
with_cuda = os.environ.get('SINGA_CUDA', False)
with_nccl = os.environ.get('SINGA_NCCL', False)
with_test = os.environ.get('SINGA_TEST', False)
with_debug = os.environ.get('SINGA_DEBUG', False)
return with_cuda, with_nccl, with_test, with_debug
def generate_singa_config(with_cuda, with_nccl):
'''Generate singa_config.h file to define some macros for the cpp code.
with_cuda(bool): indicator for cudnn and cuda lib
with_nccl(bool): indicator for nccl lib
config = ['#define USE_CBLAS', '#define USE_GLOG', '#define USE_DNNL']
if not with_cuda:
config.append('#define CPU_ONLY')
config.append('#define USE_CUDA')
config.append('#define USE_CUDNN')
if with_nccl:
config.append('#define ENABLE_DIST')
config.append('#define USE_DIST')
# singa_config.h to be included by cpp code
cpp_conf_path = SINGA_HDR / 'singa/singa_config.h'
print('Writing configs to {}'.format(cpp_conf_path))
with'w') as fd:
for line in config:
fd.write(line + '\n')
versions = [int(x) for x in VERSION.split('+')[0].split('.')[:3]]
fd.write('#define SINGA_MAJOR_VERSION {}\n'.format(versions[0]))
fd.write('#define SINGA_MINOR_VERSION {}\n'.format(versions[1]))
fd.write('#define SINGA_PATCH_VERSION {}\n'.format(versions[2]))
fd.write('#define SINGA_VERSION "{}"\n'.format(VERSION))
# config.i to be included by swig files
swig_conf_path = SINGA_SRC / 'api/config.i'
with'w') as fd:
for line in config:
fd.write(line + ' 1 \n')
fd.write('#define USE_PYTHON 1\n')
if not with_nccl:
fd.write('#define USE_DIST 0\n')
if not with_cuda:
fd.write('#define USE_CUDA 0\n')
fd.write('#define USE_CUDNN 0\n')
fd.write('#define CUDNN_VERSION "{}"\n'.format(
versions = [int(x) for x in VERSION.split('+')[0].split('.')[:3]]
fd.write('#define SINGA_MAJOR_VERSION {}\n'.format(versions[0]))
fd.write('#define SINGA_MINOR_VERSION {}\n'.format(versions[1]))
fd.write('#define SINGA_PATCH_VERSION {}\n'.format(versions[2]))
fd.write('#define SINGA_VERSION "{}"\n'.format(VERSION))
def get_cpp_flags():
default_flags = ['-std=c++11', '-fPIC', '-g', '-O2', '-Wall', '-pthread']
# avx_flags = [ '-mavx'] #'-mf16c',
if sys.platform == 'darwin':
# Darwin most likely will have Clang, which has libc++.
return default_flags + ['-stdlib=libc++']
return default_flags
def generate_proto_files():
print('Generating proto files')
proto_src = SINGA_SRC / 'proto'
cmd = "/usr/bin/protoc --proto_path={} --cpp_out={} {}".format(
proto_src, proto_src, proto_src / 'core.proto'), shell=True, check=True)
proto_hdr_dir = SINGA_HDR / 'singa/proto'
proto_hdr_file = proto_hdr_dir / 'core.pb.h'
if proto_hdr_dir.exists():
if proto_hdr_file.exists():
shutil.copyfile(Path(proto_src / 'core.pb.h'), proto_hdr_file)
return proto_hdr_file, proto_src / ''
def path_to_str(path_list):
return [str(x) if not isinstance(x, str) else x for x in path_list]
def prepare_extension_options():
with_cuda, with_nccl, with_test, with_debug = parse_compile_options()
generate_singa_config(with_cuda, with_nccl)
link_libs = ['glog', 'protobuf', 'openblas', 'dnnl']
sources = path_to_str([
*list((SINGA_SRC / 'core').rglob('*.cc')), *list(
(SINGA_SRC / 'model/operation').glob('*.cc')), *list(
(SINGA_SRC / 'utils').glob('*.cc')),
SINGA_SRC / 'proto/', SINGA_SRC / 'api/singa.i'
include_dirs = path_to_str([
SINGA_HDR, SINGA_HDR / 'singa/proto',
np.get_include(), '/usr/include', '/usr/include/openblas',
np_include = np.get_include()
except AttributeError:
np_include = np.get_numpy_include()
library_dirs = [] # path_to_str(['/usr/lib64', '/usr/local/lib'])
if with_cuda:
link_libs.extend(['cudart', 'cudnn', 'curand', 'cublas', 'cnmem'])
sources.append(str(SINGA_SRC / 'core/tensor/'))
if with_nccl:
link_libs.extend(['nccl', 'cusparse', 'mpicxx', 'mpi'])
sources.append(str(SINGA_SRC / 'io/'))
# print(link_libs, extra_libs)
libraries = link_libs
runtime_library_dirs = ['.'] + library_dirs
extra_compile_args = {'gcc': get_cpp_flags()}
if with_cuda:
# compute_35 and compute_50 are removed because 1. they do not support half float;
# 2. google colab's GPU has been updated from K80 (compute_35) to T4 (compute_75).
cuda9_gencode = (' -gencode arch=compute_60,code=sm_60'
' -gencode arch=compute_70,code=sm_70')
cuda10_gencode = ' -gencode arch=compute_75,code=sm_75'
cuda11_gencode = ' -gencode arch=compute_80,code=sm_80'
cuda9_ptx = ' -gencode arch=compute_70,code=compute_70'
cuda10_ptx = ' -gencode arch=compute_75,code=compute_75'
cuda11_ptx = ' -gencode arch=compute_80,code=compute_80'
if cuda_major >= 11:
gencode = cuda9_gencode + cuda10_gencode + cuda11_gencode + cuda11_ptx
elif cuda_major >= 10:
gencode = cuda9_gencode + cuda10_gencode + cuda10_ptx
elif cuda_major >= 9:
gencode = cuda9_gencode + cuda9_ptx
raise CompileError(
'CUDA version must be >=9.0, the current version is {}'.format(
extra_compile_args['nvcc'] = shlex.split(gencode) + [
'-Xcompiler', '-fPIC'
options = {
'sources': sources,
'include_dirs': include_dirs,
'library_dirs': library_dirs,
'libraries': libraries,
'runtime_library_dirs': runtime_library_dirs,
'extra_compile_args': extra_compile_args
return options
# credit:
def customize_compiler_for_nvcc(self):
"""Inject deep into distutils to customize how the dispatch
to gcc/nvcc works.
If you subclass UnixCCompiler, it's not trivial to get your subclass
injected in, and still have the right customizations (i.e.
distutils.sysconfig.customize_compiler) run on it. So instead of going
the OO route, I have this. Note, it's kindof like a wierd functional
subclassing going on.
# Tell the compiler it can processes .cu
# Save references to the default compiler_so and _comple methods
default_compiler_so = self.compiler_so
super = self._compile
# Now redefine the _compile method. This gets executed for each
# object but distutils doesn't have the ability to change compilers
# based on source extension: we add it.
def _compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
if os.path.splitext(src)[1] == '.cu':
# use the cuda for .cu files
self.set_executable('compiler_so', 'nvcc')
# use only a subset of the extra_postargs, which are 1-1
# translated from the extra_compile_args in the Extension class
postargs = extra_postargs['nvcc']
postargs = extra_postargs['gcc']
super(obj, src, ext, cc_args, postargs, pp_opts)
# Reset the default compiler_so, which we might have changed for cuda
self.compiler_so = default_compiler_so
# Inject our redefined _compile method into the class
self._compile = _compile
class custom_build_ext(build_ext):
'''Customize the process for building the extension by chaning
the options for compiling swig files and cu files.
def finalize_options(self):
self.swig_cpp = True
print('build temp', self.build_temp)
print('build lib', self.build_lib)
super(custom_build_ext, self).finalize_options()
self.swig_opts = '-py3 -outdir {}/singa/'.format(self.build_lib).split()
print('build temp', self.build_temp)
print('build lib', self.build_lib)
def build_extensions(self):
options = prepare_extension_options()
for key, val in options.items():
singa_wrap.__dict__[key] = val
with'', encoding='utf-8') as f:
long_description = '\n' +
except OSError:
long_description = ''
classifiers = [
# Trove classifiers
# Full list:
'License :: OSI Approved :: Apache Software License',
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Topic :: Scientific/Engineering :: Artificial Intelligence'
if sys.platform == 'darwin':
classifiers.append('Operating System :: MacOS :: MacOS X')
elif sys.platform == 'linux':
'Operating System :: POSIX :: Linux'
raise DistutilsSetupError('Building on Windows is not supported currently.')
keywords = 'deep learning, apache singa'
with_cuda, with_nccl, _, _ = parse_compile_options()
if with_cuda:
classifiers.append('Environment :: GPU :: NVIDIA CUDA')
cuda_version = os.environ.get('CUDA_VERSION')
cudnn_version = os.environ.get('CUDNN_VERSION')
keywords += ', cuda{}, cudnn{}'.format(cuda_version, cudnn_version)
cuda_major = int(cuda_version.split('.')[0])
cuda_minor = int(cuda_version.split('.')[1])
# local label '+cuda10.2'. Ref:
VERSION = VERSION + '+cuda{}.{}'.format(cuda_major, cuda_minor)
if with_nccl:
classifiers.append('Topic :: System :: Distributed Computing')
keywords += ', distributed'
keywords += ', cpu-only'
singa_wrap = Extension('singa._singa_wrap', [])
description='A General Deep Learning System',
author='Apache SINGA Community',
'numpy >=1.16,<2.0', #1.16
license='Apache 2',
package_dir={'': 'python'},
'build_ext': custom_build_ext,
'audit': AuditCommand