'tensorflow/lite/ios/BUILD', 'tensorflow/lite/objc/BUILD',

'tensorflow/lite/swift/BUILD',

'tensorflow/lite/tools/benchmark/experimental/ios/BUILD'

try:

try:

answer = raw_input(question)

except NameError:

answer = input(question) # pylint: disable=bad-builtin

except EOFError:

answer = ''

"""Force symlink, equivalent of 'ln -sf'.

Args:

target: items to link to.

link_name: name of the link.

"""

try:

os.symlink(target, link_name)

except OSError as e:

if e.errno == errno.EEXIST:

os.remove(link_name)

os.symlink(target, link_name)

else:

if stderr is None:

stderr = sys.stdout

if allow_non_zero:

try:

output = subprocess.check_output(cmd, stderr=stderr)

except subprocess.CalledProcessError as e:

output = e.output

else:

output = subprocess.check_output(cmd, stderr=stderr)

"""Get the python site package paths."""

python_paths = []

if environ_cp.get('PYTHONPATH'):

python_paths = environ_cp.get('PYTHONPATH').split(':')

try:

stderr = open(os.devnull, 'wb')

library_paths = run_shell([

python_bin_path, '-c',

'import site; print("\\n".join(site.getsitepackages()))'

],

stderr=stderr).split('\n')

except subprocess.CalledProcessError:

library_paths = [

run_shell([

python_bin_path, '-c',

'from distutils.sysconfig import get_python_lib;'

'print(get_python_lib())'

])

]

all_paths = set(python_paths + library_paths)

# Sort set so order is deterministic

all_paths = sorted(all_paths)

paths = []

for path in all_paths:

if os.path.isdir(path):

paths.append(path)

"""Setup python related env variables."""

# Get PYTHON_BIN_PATH, default is the current running python.

default_python_bin_path = sys.executable

ask_python_bin_path = ('Please specify the location of python. [Default is '

'{}]: ').format(default_python_bin_path)

while True:

python_bin_path = get_from_env_or_user_or_default(environ_cp,

'PYTHON_BIN_PATH',

ask_python_bin_path,

default_python_bin_path)

# Check if the path is valid

if os.path.isfile(python_bin_path) and os.access(python_bin_path, os.X_OK):

break

elif not os.path.exists(python_bin_path):

print('Invalid python path: {} cannot be found.'.format(python_bin_path))

else:

print('{} is not executable. Is it the python binary?'.format(

python_bin_path))

environ_cp['PYTHON_BIN_PATH'] = ''

# Convert python path to Windows style before checking lib and version

if is_windows() or is_cygwin():

python_bin_path = cygpath(python_bin_path)

# Get PYTHON_LIB_PATH

python_lib_path = environ_cp.get('PYTHON_LIB_PATH')

if not python_lib_path:

python_lib_paths = get_python_path(environ_cp, python_bin_path)

if environ_cp.get('USE_DEFAULT_PYTHON_LIB_PATH') == '1':

python_lib_path = python_lib_paths[0]

else:

print('Found possible Python library paths:\n %s' %

'\n '.join(python_lib_paths))

default_python_lib_path = python_lib_paths[0]

python_lib_path = get_input(

'Please input the desired Python library path to use. '

'Default is [{}]\n'.format(python_lib_paths[0]))

if not python_lib_path:

python_lib_path = default_python_lib_path

environ_cp['PYTHON_LIB_PATH'] = python_lib_path

python_major_version = get_python_major_version(python_bin_path)

if python_major_version == '2':

write_to_bazelrc('build --host_force_python=PY2')

# Convert python path to Windows style before writing into bazel.rc

if is_windows() or is_cygwin():

python_lib_path = cygpath(python_lib_path)

# Set-up env variables used by python_configure.bzl

write_action_env_to_bazelrc('PYTHON_BIN_PATH', python_bin_path)

write_action_env_to_bazelrc('PYTHON_LIB_PATH', python_lib_path)

write_to_bazelrc('build --python_path=\"{}"'.format(python_bin_path))

environ_cp['PYTHON_BIN_PATH'] = python_bin_path

# If choosen python_lib_path is from a path specified in the PYTHONPATH

# variable, need to tell bazel to include PYTHONPATH

if environ_cp.get('PYTHONPATH'):

python_paths = environ_cp.get('PYTHONPATH').split(':')

if python_lib_path in python_paths:

write_action_env_to_bazelrc('PYTHONPATH', environ_cp.get('PYTHONPATH'))

# Write tools/python_bin_path.sh

with open(

os.path.join(_TF_WORKSPACE_ROOT, 'tools', 'python_bin_path.sh'),

'w') as f:

"""Delete any leftover BUILD files from the Makefile build.

These files could interfere with Bazel parsing.

"""

makefile_download_dir = os.path.join(_TF_WORKSPACE_ROOT, 'tensorflow',

'contrib', 'makefile', 'downloads')

if os.path.isdir(makefile_download_dir):

for root, _, filenames in os.walk(makefile_download_dir):

for f in filenames:

if f.endswith('BUILD'):

var_name,

query_item,

enabled_by_default,

question=None,

yes_reply=None,

no_reply=None):

"""Get boolean input from user.

If var_name is not set in env, ask user to enable query_item or not. If the

response is empty, use the default.

Args:

environ_cp: copy of the os.environ.

var_name: string for name of environment variable, e.g. "TF_NEED_CUDA".

query_item: string for feature related to the variable, e.g. "CUDA for

Nvidia GPUs".

enabled_by_default: boolean for default behavior.

question: optional string for how to ask for user input.

yes_reply: optional string for reply when feature is enabled.

no_reply: optional string for reply when feature is disabled.

Returns:

boolean value of the variable.

Raises:

UserInputError: if an environment variable is set, but it cannot be

interpreted as a boolean indicator, assume that the user has made a

scripting error, and will continue to provide invalid input.

Raise the error to avoid infinitely looping.

"""

if not question:

question = 'Do you wish to build TensorFlow with {} support?'.format(

query_item)

if not yes_reply:

yes_reply = '{} support will be enabled for TensorFlow.'.format(query_item)

if not no_reply:

no_reply = 'No {}'.format(yes_reply)

yes_reply += '\n'

no_reply += '\n'

if enabled_by_default:

question += ' [Y/n]: '

else:

question += ' [y/N]: '

var = environ_cp.get(var_name)

if var is not None:

var_content = var.strip().lower()

true_strings = ('1', 't', 'true', 'y', 'yes')

false_strings = ('0', 'f', 'false', 'n', 'no')

if var_content in true_strings:

var = True

elif var_content in false_strings:

var = False

else:

raise UserInputError(

'Environment variable %s must be set as a boolean indicator.\n'

'The following are accepted as TRUE : %s.\n'

'The following are accepted as FALSE: %s.\n'

'Current value is %s.' %

(var_name, ', '.join(true_strings), ', '.join(false_strings), var))

while var is None:

user_input_origin = get_input(question)

user_input = user_input_origin.strip().lower()

if user_input == 'y':

print(yes_reply)

var = True

elif user_input == 'n':

print(no_reply)

var = False

elif not user_input:

if enabled_by_default:

print(yes_reply)

var = True

else:

print(no_reply)

var = False

else:

print('Invalid selection: {}'.format(user_input_origin))

var_name,

query_item,

enabled_by_default,

question=None,

yes_reply=None,

no_reply=None,

bazel_config_name=None):

"""Set boolean action_env variable.

Ask user if query_item will be enabled. Default is used if no input is given.

Set environment variable and write to .bazelrc.

Args:

environ_cp: copy of the os.environ.

var_name: string for name of environment variable, e.g. "TF_NEED_CUDA".

query_item: string for feature related to the variable, e.g. "CUDA for

Nvidia GPUs".

enabled_by_default: boolean for default behavior.

question: optional string for how to ask for user input.

yes_reply: optional string for reply when feature is enabled.

no_reply: optional string for reply when feature is disabled.

bazel_config_name: adding config to .bazelrc instead of action_env.

"""

var = int(

get_var(environ_cp, var_name, query_item, enabled_by_default, question,

yes_reply, no_reply))

if not bazel_config_name:

write_action_env_to_bazelrc(var_name, var)

elif var:

write_to_bazelrc('build --config=%s' % bazel_config_name)

"""Convert a version number to a integer that can be used to compare.

Version strings of the form X.YZ and X.Y.Z-xxxxx are supported. The

'xxxxx' part, for instance 'homebrew' on OS/X, is ignored.

Args:

version: a version to be converted

Returns:

An integer if converted successfully, otherwise return None.

"""

version = version.split('-')[0]

version_segments = version.split('.')

# Treat "0.24" as "0.24.0"

if len(version_segments) == 2:

version_segments.append('0')

for seg in version_segments:

if not seg.isdigit():

return None

version_str = ''.join(['%03d' % int(seg) for seg in version_segments])

"""Retrieve installed bazel version (or bazelisk).

Returns:

The bazel version detected.

"""

bazel_executable = which('bazel')

if bazel_executable is None:

bazel_executable = which('bazelisk')

if bazel_executable is None:

print('Cannot find bazel. Please install bazel/bazelisk.')

sys.exit(1)

stderr = open(os.devnull, 'wb')

curr_version = run_shell([bazel_executable, '--version'],

allow_non_zero=True,

stderr=stderr)

if curr_version.startswith('bazel '):

curr_version = curr_version.split('bazel ')[1]

curr_version_int = convert_version_to_int(curr_version)

# Check if current bazel version can be detected properly.

if not curr_version_int:

print('WARNING: current bazel installation is not a release version.')

return curr_version

print('You have bazel %s installed.' % curr_version)

"""Set up architecture-dependent optimization flags.

Also append CC optimization flags to bazel.rc..

Args:

environ_cp: copy of the os.environ.

"""

if is_ppc64le():

# gcc on ppc64le does not support -march, use mcpu instead

default_cc_opt_flags = '-mcpu=native'

elif is_windows():

default_cc_opt_flags = '/arch:AVX'

else:

# On all other platforms, no longer use `-march=native` as this can result

# in instructions that are too modern being generated. Users that want

# maximum performance should compile TF in their environment and can pass

# `-march=native` there.

# See https://github.com/tensorflow/tensorflow/issues/45744 and duplicates

default_cc_opt_flags = '-Wno-sign-compare'

question = ('Please specify optimization flags to use during compilation when'

' bazel option "--config=opt" is specified [Default is %s]: '

) % default_cc_opt_flags

cc_opt_flags = get_from_env_or_user_or_default(environ_cp, 'CC_OPT_FLAGS',

question, default_cc_opt_flags)

for opt in cc_opt_flags.split():

write_to_bazelrc('build:opt --copt=%s' % opt)

"""set TF_CUDA_CLANG action_env.

Args:

environ_cp: copy of the os.environ.

"""

question = 'Do you want to use clang as CUDA compiler?'

yes_reply = 'Clang will be used as CUDA compiler.'

no_reply = 'nvcc will be used as CUDA compiler.'

set_action_env_var(

environ_cp,

'TF_CUDA_CLANG',

None,

False,

question=question,

yes_reply=yes_reply,

no_reply=no_reply,

"""Set TF_DOWNLOAD_CLANG action_env."""

question = 'Do you wish to download a fresh release of clang? (Experimental)'

yes_reply = 'Clang will be downloaded and used to compile tensorflow.'

no_reply = 'Clang will not be downloaded.'

set_action_env_var(

environ_cp,

'TF_DOWNLOAD_CLANG',

None,

False,

question=question,

yes_reply=yes_reply,

no_reply=no_reply,

var_default):

"""Get var_name either from env, or user or default.

If var_name has been set as environment variable, use the preset value, else

ask for user input. If no input is provided, the default is used.

Args:

environ_cp: copy of the os.environ.

var_name: string for name of environment variable, e.g. "TF_NEED_CUDA".

ask_for_var: string for how to ask for user input.

var_default: default value string.

Returns:

string value for var_name

"""

var = environ_cp.get(var_name)

if not var:

var = get_input(ask_for_var)

print('\n')

if not var:

var = var_default

"""Set CLANG_CUDA_COMPILER_PATH."""

default_clang_path = which('clang') or ''

ask_clang_path = ('Please specify which clang should be used as device and '

'host compiler. [Default is %s]: ') % default_clang_path

while True:

clang_cuda_compiler_path = get_from_env_or_user_or_default(

environ_cp, 'CLANG_CUDA_COMPILER_PATH', ask_clang_path,

default_clang_path)

if os.path.exists(clang_cuda_compiler_path):

break

# Reset and retry

print('Invalid clang path: %s cannot be found.' % clang_cuda_compiler_path)

environ_cp['CLANG_CUDA_COMPILER_PATH'] = ''

# Set CLANG_CUDA_COMPILER_PATH

environ_cp['CLANG_CUDA_COMPILER_PATH'] = clang_cuda_compiler_path

write_action_env_to_bazelrc('CLANG_CUDA_COMPILER_PATH',

var_name,

var_default,

ask_for_var,

check_success,

error_msg,

suppress_default_error=False,

resolve_symlinks=False,

n_ask_attempts=_DEFAULT_PROMPT_ASK_ATTEMPTS):

"""Loop over user prompts for an ENV param until receiving a valid response.

For the env param var_name, read from the environment or verify user input

until receiving valid input. When done, set var_name in the environ_cp to its

new value.

Args:

environ_cp: (Dict) copy of the os.environ.

var_name: (String) string for name of environment variable, e.g. "TF_MYVAR".

var_default: (String) default value string.

ask_for_var: (String) string for how to ask for user input.

check_success: (Function) function that takes one argument and returns a

boolean. Should return True if the value provided is considered valid. May

contain a complex error message if error_msg does not provide enough

information. In that case, set suppress_default_error to True.

error_msg: (String) String with one and only one '%s'. Formatted with each

invalid response upon check_success(input) failure.

suppress_default_error: (Bool) Suppress the above error message in favor of

one from the check_success function.

resolve_symlinks: (Bool) Translate symbolic links into the real filepath.

n_ask_attempts: (Integer) Number of times to query for valid input before

raising an error and quitting.

Returns:

[String] The value of var_name after querying for input.

Raises:

UserInputError: if a query has been attempted n_ask_attempts times without

success, assume that the user has made a scripting error, and will

continue to provide invalid input. Raise the error to avoid infinitely

looping.

"""

default = environ_cp.get(var_name) or var_default

full_query = '%s [Default is %s]: ' % (

ask_for_var,

default,

)

for _ in range(n_ask_attempts):

val = get_from_env_or_user_or_default(environ_cp, var_name, full_query,

default)

if check_success(val):

break

if not suppress_default_error:

print(error_msg % val)

environ_cp[var_name] = ''

else:

raise UserInputError('Invalid %s setting was provided %d times in a row. '

'Assuming to be a scripting mistake.' %

(var_name, n_ask_attempts))

if resolve_symlinks:

val = os.path.realpath(val)

environ_cp[var_name] = val

"""Set ANDROID_NDK_HOME and write Android NDK WORKSPACE rule."""

if is_windows() or is_cygwin():

default_ndk_path = cygpath('%s/Android/Sdk/ndk-bundle' %

environ_cp['APPDATA'])

elif is_macos():

default_ndk_path = '%s/library/Android/Sdk/ndk-bundle' % environ_cp['HOME']

else:

default_ndk_path = '%s/Android/Sdk/ndk-bundle' % environ_cp['HOME']

def valid_ndk_path(path):

return (os.path.exists(path) and

os.path.exists(os.path.join(path, 'source.properties')))

android_ndk_home_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_NDK_HOME',

var_default=default_ndk_path,

ask_for_var='Please specify the home path of the Android NDK to use.',

check_success=valid_ndk_path,

error_msg=('The path %s or its child file "source.properties" '

'does not exist.'))

write_action_env_to_bazelrc('ANDROID_NDK_HOME', android_ndk_home_path)

write_action_env_to_bazelrc(

'ANDROID_NDK_API_LEVEL',

"""Set Android variables and write Android SDK WORKSPACE rule."""

if is_windows() or is_cygwin():

default_sdk_path = cygpath('%s/Android/Sdk' % environ_cp['APPDATA'])

elif is_macos():

default_sdk_path = '%s/library/Android/Sdk' % environ_cp['HOME']

else:

default_sdk_path = '%s/Android/Sdk' % environ_cp['HOME']

def valid_sdk_path(path):

return (os.path.exists(path) and

os.path.exists(os.path.join(path, 'platforms')) and

os.path.exists(os.path.join(path, 'build-tools')))

android_sdk_home_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_SDK_HOME',

var_default=default_sdk_path,

ask_for_var='Please specify the home path of the Android SDK to use.',

check_success=valid_sdk_path,

error_msg=('Either %s does not exist, or it does not contain the '

'subdirectories "platforms" and "build-tools".'))

platforms = os.path.join(android_sdk_home_path, 'platforms')

api_levels = sorted(os.listdir(platforms))

api_levels = [x.replace('android-', '') for x in api_levels]

def valid_api_level(api_level):

return os.path.exists(

os.path.join(android_sdk_home_path, 'platforms',

'android-' + api_level))

android_api_level = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_API_LEVEL',

var_default=api_levels[-1],

ask_for_var=('Please specify the Android SDK API level to use. '

'[Available levels: %s]') % api_levels,

check_success=valid_api_level,

error_msg='Android-%s is not present in the SDK path.')

build_tools = os.path.join(android_sdk_home_path, 'build-tools')

versions = sorted(os.listdir(build_tools))

def valid_build_tools(version):

return os.path.exists(

os.path.join(android_sdk_home_path, 'build-tools', version))

android_build_tools_version = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_BUILD_TOOLS_VERSION',

var_default=versions[-1],

ask_for_var=('Please specify an Android build tools version to use. '

'[Available versions: %s]') % versions,

check_success=valid_build_tools,

error_msg=('The selected SDK does not have build-tools version %s '

'available.'))

write_action_env_to_bazelrc('ANDROID_BUILD_TOOLS_VERSION',

android_build_tools_version)

write_action_env_to_bazelrc('ANDROID_SDK_API_LEVEL', android_api_level)

"""Gets the appropriate NDK API level to use for the provided Android NDK path.

"""

# First check to see if we're using a blessed version of the NDK.

properties_path = '%s/source.properties' % android_ndk_home_path

if is_windows() or is_cygwin():

properties_path = cygpath(properties_path)

with open(properties_path, 'r') as f:

filedata = f.read()

revision = re.search(r'Pkg.Revision = (\d+)', filedata)

if revision:

ndk_version = revision.group(1)

else:

raise Exception('Unable to parse NDK revision.')

if int(ndk_version) not in _SUPPORTED_ANDROID_NDK_VERSIONS:

print('WARNING: The NDK version in %s is %s, which is not '

'supported by Bazel (officially supported versions: %s). Please use '

'another version. Compiling Android targets may result in confusing '

'errors.\n' %

(android_ndk_home_path, ndk_version, _SUPPORTED_ANDROID_NDK_VERSIONS))

# Now grab the NDK API level to use. Note that this is different from the

# SDK API level, as the NDK API level is effectively the *min* target SDK

# version.

platforms = os.path.join(android_ndk_home_path, 'platforms')

api_levels = sorted(os.listdir(platforms))

api_levels = [

x.replace('android-', '') for x in api_levels if 'android-' in x

]

def valid_api_level(api_level):

return os.path.exists(

os.path.join(android_ndk_home_path, 'platforms',

'android-' + api_level))

android_ndk_api_level = prompt_loop_or_load_from_env(

environ_cp,

var_name='ANDROID_NDK_API_LEVEL',

var_default='21', # 21 is required for ARM64 support.

ask_for_var=('Please specify the (min) Android NDK API level to use. '

'[Available levels: %s]') % api_levels,

check_success=valid_api_level,

error_msg='Android-%s is not present in the NDK path.')

"""Set GCC_HOST_COMPILER_PATH."""

default_gcc_host_compiler_path = which('gcc') or ''

cuda_bin_symlink = '%s/bin/gcc' % environ_cp.get('CUDA_TOOLKIT_PATH')

if os.path.islink(cuda_bin_symlink):

# os.readlink is only available in linux

default_gcc_host_compiler_path = os.path.realpath(cuda_bin_symlink)

gcc_host_compiler_path = prompt_loop_or_load_from_env(

environ_cp,

var_name='GCC_HOST_COMPILER_PATH',

var_default=default_gcc_host_compiler_path,

ask_for_var='Please specify which gcc should be used by nvcc as the host '

'compiler.',

check_success=os.path.exists,

resolve_symlinks=True,

error_msg='Invalid gcc path. %s cannot be found.',

)

"""Set TF_CUDA_PATHS."""

ask_cuda_paths = (

'Please specify the comma-separated list of base paths to look for CUDA '

'libraries and headers. [Leave empty to use the default]: ')

tf_cuda_paths = get_from_env_or_user_or_default(environ_cp, 'TF_CUDA_PATHS',

ask_cuda_paths, '')

if tf_cuda_paths:

"""Set TF_CUDA_VERSION."""

ask_cuda_version = (

'Please specify the CUDA SDK version you want to use. '

'[Leave empty to default to CUDA %s]: ') % _DEFAULT_CUDA_VERSION

tf_cuda_version = get_from_env_or_user_or_default(environ_cp,

'TF_CUDA_VERSION',

ask_cuda_version,

_DEFAULT_CUDA_VERSION)

"""Set TF_CUDNN_VERSION."""

ask_cudnn_version = (

'Please specify the cuDNN version you want to use. '

'[Leave empty to default to cuDNN %s]: ') % _DEFAULT_CUDNN_VERSION

tf_cudnn_version = get_from_env_or_user_or_default(environ_cp,

'TF_CUDNN_VERSION',

ask_cudnn_version,

_DEFAULT_CUDNN_VERSION)

"""Set TF_TENSORRT_VERSION."""

if not (is_linux() or is_windows()):

raise ValueError('Currently TensorRT is only supported on Linux platform.')

if not int(environ_cp.get('TF_NEED_TENSORRT', False)):

return

ask_tensorrt_version = (

'Please specify the TensorRT version you want to use. '

'[Leave empty to default to TensorRT %s]: ') % _DEFAULT_TENSORRT_VERSION

tf_tensorrt_version = get_from_env_or_user_or_default(

environ_cp, 'TF_TENSORRT_VERSION', ask_tensorrt_version,

_DEFAULT_TENSORRT_VERSION)

"""Set TF_NCCL_VERSION."""

if not is_linux():

raise ValueError('Currently NCCL is only supported on Linux platform.')

if 'TF_NCCL_VERSION' in environ_cp:

return

ask_nccl_version = (

'Please specify the locally installed NCCL version you want to use. '

'[Leave empty to use http://github.com/nvidia/nccl]: ')

tf_nccl_version = get_from_env_or_user_or_default(environ_cp,

'TF_NCCL_VERSION',

ask_nccl_version, '')

"""Get native cuda compute capabilities.

Args:

environ_cp: copy of the os.environ.

Returns:

string of native cuda compute capabilities, separated by comma.

"""

device_query_bin = os.path.join(

environ_cp.get('CUDA_TOOLKIT_PATH'), 'extras/demo_suite/deviceQuery')

if os.path.isfile(device_query_bin) and os.access(device_query_bin, os.X_OK):

try:

output = run_shell(device_query_bin).split('\n')

pattern = re.compile('[0-9]*\\.[0-9]*')

output = [pattern.search(x) for x in output if 'Capability' in x]

output = ','.join(x.group() for x in output if x is not None)

except subprocess.CalledProcessError:

output = ''

else:

output = ''

"""Set TF_CUDA_COMPUTE_CAPABILITIES."""

while True:

native_cuda_compute_capabilities = get_native_cuda_compute_capabilities(

environ_cp)

if not native_cuda_compute_capabilities:

default_cuda_compute_capabilities = _DEFAULT_CUDA_COMPUTE_CAPABILITIES

else:

default_cuda_compute_capabilities = native_cuda_compute_capabilities

ask_cuda_compute_capabilities = (

'Please specify a list of comma-separated CUDA compute capabilities '

'you want to build with.\nYou can find the compute capability of your '

'device at: https://developer.nvidia.com/cuda-gpus. Each capability '

'can be specified as "x.y" or "compute_xy" to include both virtual and'

' binary GPU code, or as "sm_xy" to only include the binary '

'code.\nPlease note that each additional compute capability '

'significantly increases your build time and binary size, and that '

'TensorFlow only supports compute capabilities >= 3.5 [Default is: '

'%s]: ' % default_cuda_compute_capabilities)

tf_cuda_compute_capabilities = get_from_env_or_user_or_default(

environ_cp, 'TF_CUDA_COMPUTE_CAPABILITIES',

ask_cuda_compute_capabilities, default_cuda_compute_capabilities)

# Check whether all capabilities from the input is valid

all_valid = True

# Remove all whitespace characters before splitting the string

# that users may insert by accident, as this will result in error

tf_cuda_compute_capabilities = ''.join(tf_cuda_compute_capabilities.split())

for compute_capability in tf_cuda_compute_capabilities.split(','):

m = re.match('[0-9]+.[0-9]+', compute_capability)

if not m:

# We now support sm_35,sm_50,sm_60,compute_70.

sm_compute_match = re.match('(sm|compute)_?([0-9]+[0-9]+)',

compute_capability)

if not sm_compute_match:

print('Invalid compute capability: %s' % compute_capability)

all_valid = False

else:

ver = int(sm_compute_match.group(2))

if ver < 30:

print(

'ERROR: TensorFlow only supports small CUDA compute'

' capabilities of sm_30 and higher. Please re-specify the list'

' of compute capabilities excluding version %s.' % ver)

all_valid = False

if ver < 35:

print('WARNING: XLA does not support CUDA compute capabilities '

'lower than sm_35. Disable XLA when running on older GPUs.')

else:

ver = float(m.group(0))

if ver < 3.0:

print('ERROR: TensorFlow only supports CUDA compute capabilities 3.0 '

'and higher. Please re-specify the list of compute '

'capabilities excluding version %s.' % ver)

all_valid = False

if ver < 3.5:

print('WARNING: XLA does not support CUDA compute capabilities '

'lower than 3.5. Disable XLA when running on older GPUs.')

if all_valid:

break

# Reset and Retry

environ_cp['TF_CUDA_COMPUTE_CAPABILITIES'] = ''

# Set TF_CUDA_COMPUTE_CAPABILITIES

environ_cp['TF_CUDA_COMPUTE_CAPABILITIES'] = tf_cuda_compute_capabilities

write_action_env_to_bazelrc('TF_CUDA_COMPUTE_CAPABILITIES',

"""Set other CUDA related variables."""

# If CUDA is enabled, always use GPU during build and test.

if environ_cp.get('TF_CUDA_CLANG') == '1':

write_to_bazelrc('build --config=cuda_clang')

else:

"""Add default build and test flags required for TF tests to bazelrc."""

write_to_bazelrc('test --flaky_test_attempts=3')

write_to_bazelrc('test --test_size_filters=small,medium')

# Each instance of --test_tag_filters or --build_tag_filters overrides all

# previous instances, so we need to build up a complete list and write a

# single list of filters for the .bazelrc file.

# Filters to use with both --test_tag_filters and --build_tag_filters

test_and_build_filters = ['-benchmark-test', '-no_oss']

# Additional filters for --test_tag_filters beyond those in

# test_and_build_filters

test_only_filters = ['-oss_serial']

if is_windows():

test_and_build_filters.append('-no_windows')

if ((environ_cp.get('TF_NEED_CUDA', None) == '1') or

(environ_cp.get('TF_NEED_ROCM', None) == '1')):

test_and_build_filters += ['-no_windows_gpu', '-no_gpu']

else:

test_and_build_filters.append('-gpu')

elif is_macos():

test_and_build_filters += ['-gpu', '-nomac', '-no_mac']

elif is_linux():

if ((environ_cp.get('TF_NEED_CUDA', None) == '1') or

(environ_cp.get('TF_NEED_ROCM', None) == '1')):

test_and_build_filters.append('-no_gpu')

write_to_bazelrc('test --test_env=LD_LIBRARY_PATH')

else:

test_and_build_filters.append('-gpu')

# Disable tests with "v1only" tag in "v2" Bazel config, but not in "v1" config

write_to_bazelrc('test:v1 --test_tag_filters=%s' %

','.join(test_and_build_filters + test_only_filters))

write_to_bazelrc('test:v1 --build_tag_filters=%s' %

','.join(test_and_build_filters))