blob: f0b9fada5ec90c297949b28aef166ebe7580fabc [file] [log] [blame]
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7# http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
14# ==============================================================================
15"""configure script to get build parameters from user."""
16
17from __future__ import absolute_import
18from __future__ import division
19from __future__ import print_function
20
Shanqing Cai71445712018-03-12 19:33:52 -070021import argparse
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -070022import errno
23import os
24import platform
25import re
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -070026import subprocess
27import sys
28
Andrew Sellec9885ea2017-11-06 09:37:03 -080029# pylint: disable=g-import-not-at-top
Jonathan Hseu008910f2017-08-25 14:01:05 -070030try:
31 from shutil import which
32except ImportError:
33 from distutils.spawn import find_executable as which
Andrew Sellec9885ea2017-11-06 09:37:03 -080034# pylint: enable=g-import-not-at-top
Jonathan Hseu008910f2017-08-25 14:01:05 -070035
Dandelion Man?90e42f32017-12-15 18:15:07 -080036_DEFAULT_CUDA_VERSION = '9.0'
37_DEFAULT_CUDNN_VERSION = '7'
Smit Hinsu63e6b9b2018-07-13 12:46:24 -070038_DEFAULT_NCCL_VERSION = '2.2'
Smit Hinsufe7d1d92018-07-14 13:16:58 -070039_DEFAULT_CUDA_COMPUTE_CAPABILITIES = '3.5,7.0'
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -070040_DEFAULT_CUDA_PATH = '/usr/local/cuda'
41_DEFAULT_CUDA_PATH_LINUX = '/opt/cuda'
42_DEFAULT_CUDA_PATH_WIN = ('C:/Program Files/NVIDIA GPU Computing '
43 'Toolkit/CUDA/v%s' % _DEFAULT_CUDA_VERSION)
Benoit Steiner0dadbfe2018-03-22 18:54:27 -070044_DEFAULT_TENSORRT_PATH_LINUX = '/usr/lib/%s-linux-gnu' % platform.machine()
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -070045_TF_OPENCL_VERSION = '1.2'
46_DEFAULT_COMPUTECPP_TOOLKIT_PATH = '/usr/local/computecpp'
Yifei Fengb1d8c592017-11-22 13:42:21 -080047_DEFAULT_TRISYCL_INCLUDE_DIR = '/usr/local/triSYCL/include'
A. Unique TensorFlowerd340f472018-08-30 14:00:41 -070048_SUPPORTED_ANDROID_NDK_VERSIONS = [10, 11, 12, 13, 14, 15, 16]
Austin Anderson6afface2017-12-05 11:59:17 -080049
50_DEFAULT_PROMPT_ASK_ATTEMPTS = 10
51
Shanqing Cai71445712018-03-12 19:33:52 -070052_TF_WORKSPACE_ROOT = os.path.abspath(os.path.dirname(__file__))
53_TF_BAZELRC_FILENAME = '.tf_configure.bazelrc'
54_TF_BAZELRC = os.path.join(_TF_WORKSPACE_ROOT, _TF_BAZELRC_FILENAME)
55_TF_WORKSPACE = os.path.join(_TF_WORKSPACE_ROOT, 'WORKSPACE')
56
Austin Anderson6afface2017-12-05 11:59:17 -080057
58class UserInputError(Exception):
59 pass
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -070060
61
62def is_windows():
63 return platform.system() == 'Windows'
64
65
66def is_linux():
67 return platform.system() == 'Linux'
68
69
70def is_macos():
71 return platform.system() == 'Darwin'
72
73
74def is_ppc64le():
75 return platform.machine() == 'ppc64le'
76
77
Jonathan Hseu008910f2017-08-25 14:01:05 -070078def is_cygwin():
79 return platform.system().startswith('CYGWIN_NT')
80
81
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -070082def get_input(question):
83 try:
84 try:
85 answer = raw_input(question)
86 except NameError:
87 answer = input(question) # pylint: disable=bad-builtin
88 except EOFError:
89 answer = ''
90 return answer
91
92
93def symlink_force(target, link_name):
94 """Force symlink, equivalent of 'ln -sf'.
95
96 Args:
97 target: items to link to.
98 link_name: name of the link.
99 """
100 try:
101 os.symlink(target, link_name)
102 except OSError as e:
103 if e.errno == errno.EEXIST:
104 os.remove(link_name)
105 os.symlink(target, link_name)
106 else:
107 raise e
108
109
110def sed_in_place(filename, old, new):
111 """Replace old string with new string in file.
112
113 Args:
114 filename: string for filename.
115 old: string to replace.
116 new: new string to replace to.
117 """
118 with open(filename, 'r') as f:
119 filedata = f.read()
120 newdata = filedata.replace(old, new)
121 with open(filename, 'w') as f:
122 f.write(newdata)
123
124
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700125def write_to_bazelrc(line):
126 with open(_TF_BAZELRC, 'a') as f:
127 f.write(line + '\n')
128
129
130def write_action_env_to_bazelrc(var_name, var):
131 write_to_bazelrc('build --action_env %s="%s"' % (var_name, str(var)))
132
133
Jonathan Hseu008910f2017-08-25 14:01:05 -0700134def run_shell(cmd, allow_non_zero=False):
135 if allow_non_zero:
136 try:
137 output = subprocess.check_output(cmd)
138 except subprocess.CalledProcessError as e:
139 output = e.output
140 else:
141 output = subprocess.check_output(cmd)
142 return output.decode('UTF-8').strip()
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700143
144
145def cygpath(path):
146 """Convert path from posix to windows."""
Martin Wicked57572e2017-09-02 19:21:45 -0700147 return os.path.abspath(path).replace('\\', '/')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700148
149
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700150def get_python_path(environ_cp, python_bin_path):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700151 """Get the python site package paths."""
152 python_paths = []
153 if environ_cp.get('PYTHONPATH'):
154 python_paths = environ_cp.get('PYTHONPATH').split(':')
155 try:
Jonathan Hseu008910f2017-08-25 14:01:05 -0700156 library_paths = run_shell(
157 [python_bin_path, '-c',
Austin Anderson6afface2017-12-05 11:59:17 -0800158 'import site; print("\\n".join(site.getsitepackages()))']).split('\n')
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700159 except subprocess.CalledProcessError:
Jonathan Hseu008910f2017-08-25 14:01:05 -0700160 library_paths = [run_shell(
161 [python_bin_path, '-c',
162 'from distutils.sysconfig import get_python_lib;'
163 'print(get_python_lib())'])]
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700164
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700165 all_paths = set(python_paths + library_paths)
166
167 paths = []
168 for path in all_paths:
169 if os.path.isdir(path):
170 paths.append(path)
171 return paths
172
173
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700174def get_python_major_version(python_bin_path):
175 """Get the python major version."""
Jonathan Hseu008910f2017-08-25 14:01:05 -0700176 return run_shell([python_bin_path, '-c', 'import sys; print(sys.version[0])'])
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700177
178
Gunhan Gulsoyed89a2b2017-09-19 18:36:26 -0700179def setup_python(environ_cp):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700180 """Setup python related env variables."""
181 # Get PYTHON_BIN_PATH, default is the current running python.
182 default_python_bin_path = sys.executable
183 ask_python_bin_path = ('Please specify the location of python. [Default is '
184 '%s]: ') % default_python_bin_path
185 while True:
186 python_bin_path = get_from_env_or_user_or_default(
187 environ_cp, 'PYTHON_BIN_PATH', ask_python_bin_path,
188 default_python_bin_path)
189 # Check if the path is valid
Jonathan Hseu008910f2017-08-25 14:01:05 -0700190 if os.path.isfile(python_bin_path) and os.access(
191 python_bin_path, os.X_OK):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700192 break
193 elif not os.path.exists(python_bin_path):
194 print('Invalid python path: %s cannot be found.' % python_bin_path)
195 else:
196 print('%s is not executable. Is it the python binary?' % python_bin_path)
197 environ_cp['PYTHON_BIN_PATH'] = ''
198
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700199 # Convert python path to Windows style before checking lib and version
Martin Wicked57572e2017-09-02 19:21:45 -0700200 if is_windows() or is_cygwin():
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700201 python_bin_path = cygpath(python_bin_path)
202
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700203 # Get PYTHON_LIB_PATH
204 python_lib_path = environ_cp.get('PYTHON_LIB_PATH')
205 if not python_lib_path:
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700206 python_lib_paths = get_python_path(environ_cp, python_bin_path)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700207 if environ_cp.get('USE_DEFAULT_PYTHON_LIB_PATH') == '1':
Vijay Vasudevana1fba7f2017-07-28 10:58:56 -0700208 python_lib_path = python_lib_paths[0]
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700209 else:
Jonathan Hseu008910f2017-08-25 14:01:05 -0700210 print('Found possible Python library paths:\n %s' %
211 '\n '.join(python_lib_paths))
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700212 default_python_lib_path = python_lib_paths[0]
213 python_lib_path = get_input(
Jonathan Hseu008910f2017-08-25 14:01:05 -0700214 'Please input the desired Python library path to use. '
215 'Default is [%s]\n' % python_lib_paths[0])
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700216 if not python_lib_path:
217 python_lib_path = default_python_lib_path
Vijay Vasudevana1fba7f2017-07-28 10:58:56 -0700218 environ_cp['PYTHON_LIB_PATH'] = python_lib_path
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700219
Andrew Harp6e3e7d12017-08-21 12:10:44 -0700220 python_major_version = get_python_major_version(python_bin_path)
221
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700222 # Convert python path to Windows style before writing into bazel.rc
Martin Wicked57572e2017-09-02 19:21:45 -0700223 if is_windows() or is_cygwin():
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700224 python_lib_path = cygpath(python_lib_path)
225
226 # Set-up env variables used by python_configure.bzl
227 write_action_env_to_bazelrc('PYTHON_BIN_PATH', python_bin_path)
228 write_action_env_to_bazelrc('PYTHON_LIB_PATH', python_lib_path)
Gunhan Gulsoyed89a2b2017-09-19 18:36:26 -0700229 write_to_bazelrc('build --python_path=\"%s"' % python_bin_path)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700230 environ_cp['PYTHON_BIN_PATH'] = python_bin_path
231
232 # Write tools/python_bin_path.sh
Shanqing Cai71445712018-03-12 19:33:52 -0700233 with open(os.path.join(
234 _TF_WORKSPACE_ROOT, 'tools', 'python_bin_path.sh'), 'w') as f:
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700235 f.write('export PYTHON_BIN_PATH="%s"' % python_bin_path)
236
237
Shanqing Cai71445712018-03-12 19:33:52 -0700238def reset_tf_configure_bazelrc(workspace_path):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700239 """Reset file that contains customized config settings."""
240 open(_TF_BAZELRC, 'w').close()
Shanqing Cai71445712018-03-12 19:33:52 -0700241 bazelrc_path = os.path.join(workspace_path, '.bazelrc')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700242
Shanqing Cai71445712018-03-12 19:33:52 -0700243 data = []
244 if os.path.exists(bazelrc_path):
245 with open(bazelrc_path, 'r') as f:
246 data = f.read().splitlines()
247 with open(bazelrc_path, 'w') as f:
248 for l in data:
249 if _TF_BAZELRC_FILENAME in l:
250 continue
251 f.write('%s\n' % l)
252 if is_windows():
253 tf_bazelrc_path = _TF_BAZELRC.replace("\\", "/")
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700254 else:
Shanqing Cai71445712018-03-12 19:33:52 -0700255 tf_bazelrc_path = _TF_BAZELRC
256 f.write('import %s\n' % tf_bazelrc_path)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700257
258
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700259def cleanup_makefile():
260 """Delete any leftover BUILD files from the Makefile build.
261
262 These files could interfere with Bazel parsing.
263 """
Shanqing Cai71445712018-03-12 19:33:52 -0700264 makefile_download_dir = os.path.join(
265 _TF_WORKSPACE_ROOT, 'tensorflow', 'contrib', 'makefile', 'downloads')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700266 if os.path.isdir(makefile_download_dir):
267 for root, _, filenames in os.walk(makefile_download_dir):
268 for f in filenames:
269 if f.endswith('BUILD'):
270 os.remove(os.path.join(root, f))
271
272
273def get_var(environ_cp,
274 var_name,
275 query_item,
276 enabled_by_default,
277 question=None,
278 yes_reply=None,
279 no_reply=None):
280 """Get boolean input from user.
281
282 If var_name is not set in env, ask user to enable query_item or not. If the
283 response is empty, use the default.
284
285 Args:
286 environ_cp: copy of the os.environ.
287 var_name: string for name of environment variable, e.g. "TF_NEED_HDFS".
288 query_item: string for feature related to the variable, e.g. "Hadoop File
289 System".
290 enabled_by_default: boolean for default behavior.
291 question: optional string for how to ask for user input.
Michael Cased90054e2018-02-07 14:36:00 -0800292 yes_reply: optional string for reply when feature is enabled.
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700293 no_reply: optional string for reply when feature is disabled.
294
295 Returns:
296 boolean value of the variable.
Frank Chenc4ef9272018-01-10 11:36:52 -0800297
298 Raises:
299 UserInputError: if an environment variable is set, but it cannot be
300 interpreted as a boolean indicator, assume that the user has made a
301 scripting error, and will continue to provide invalid input.
302 Raise the error to avoid infinitely looping.
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700303 """
304 if not question:
305 question = 'Do you wish to build TensorFlow with %s support?' % query_item
306 if not yes_reply:
307 yes_reply = '%s support will be enabled for TensorFlow.' % query_item
308 if not no_reply:
309 no_reply = 'No %s' % yes_reply
310
311 yes_reply += '\n'
312 no_reply += '\n'
313
314 if enabled_by_default:
315 question += ' [Y/n]: '
316 else:
317 question += ' [y/N]: '
318
319 var = environ_cp.get(var_name)
Frank Chenc4ef9272018-01-10 11:36:52 -0800320 if var is not None:
321 var_content = var.strip().lower()
322 true_strings = ('1', 't', 'true', 'y', 'yes')
323 false_strings = ('0', 'f', 'false', 'n', 'no')
324 if var_content in true_strings:
325 var = True
326 elif var_content in false_strings:
327 var = False
328 else:
329 raise UserInputError(
330 'Environment variable %s must be set as a boolean indicator.\n'
331 'The following are accepted as TRUE : %s.\n'
332 'The following are accepted as FALSE: %s.\n'
333 'Current value is %s.' % (
334 var_name, ', '.join(true_strings), ', '.join(false_strings),
335 var))
336
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700337 while var is None:
338 user_input_origin = get_input(question)
339 user_input = user_input_origin.strip().lower()
340 if user_input == 'y':
341 print(yes_reply)
342 var = True
343 elif user_input == 'n':
344 print(no_reply)
345 var = False
346 elif not user_input:
347 if enabled_by_default:
348 print(yes_reply)
349 var = True
350 else:
351 print(no_reply)
352 var = False
353 else:
354 print('Invalid selection: %s' % user_input_origin)
355 return var
356
357
358def set_build_var(environ_cp, var_name, query_item, option_name,
Michael Case98850a52017-09-14 13:35:57 -0700359 enabled_by_default, bazel_config_name=None):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700360 """Set if query_item will be enabled for the build.
361
362 Ask user if query_item will be enabled. Default is used if no input is given.
363 Set subprocess environment variable and write to .bazelrc if enabled.
364
365 Args:
366 environ_cp: copy of the os.environ.
367 var_name: string for name of environment variable, e.g. "TF_NEED_HDFS".
368 query_item: string for feature related to the variable, e.g. "Hadoop File
369 System".
370 option_name: string for option to define in .bazelrc.
371 enabled_by_default: boolean for default behavior.
Michael Case98850a52017-09-14 13:35:57 -0700372 bazel_config_name: Name for Bazel --config argument to enable build feature.
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700373 """
374
375 var = str(int(get_var(environ_cp, var_name, query_item, enabled_by_default)))
376 environ_cp[var_name] = var
377 if var == '1':
378 write_to_bazelrc('build --define %s=true' % option_name)
Michael Case98850a52017-09-14 13:35:57 -0700379 elif bazel_config_name is not None:
380 # TODO(mikecase): Migrate all users of configure.py to use --config Bazel
381 # options and not to set build configs through environment variables.
382 write_to_bazelrc('build:%s --define %s=true'
383 % (bazel_config_name, option_name))
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700384
385
386def set_action_env_var(environ_cp,
387 var_name,
388 query_item,
389 enabled_by_default,
390 question=None,
391 yes_reply=None,
392 no_reply=None):
393 """Set boolean action_env variable.
394
395 Ask user if query_item will be enabled. Default is used if no input is given.
396 Set environment variable and write to .bazelrc.
397
398 Args:
399 environ_cp: copy of the os.environ.
400 var_name: string for name of environment variable, e.g. "TF_NEED_HDFS".
401 query_item: string for feature related to the variable, e.g. "Hadoop File
402 System".
403 enabled_by_default: boolean for default behavior.
404 question: optional string for how to ask for user input.
Michael Cased90054e2018-02-07 14:36:00 -0800405 yes_reply: optional string for reply when feature is enabled.
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700406 no_reply: optional string for reply when feature is disabled.
407 """
408 var = int(
409 get_var(environ_cp, var_name, query_item, enabled_by_default, question,
410 yes_reply, no_reply))
411
412 write_action_env_to_bazelrc(var_name, var)
413 environ_cp[var_name] = str(var)
414
415
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700416def convert_version_to_int(version):
417 """Convert a version number to a integer that can be used to compare.
418
A. Unique TensorFlower28ce1d12017-08-15 12:08:29 -0700419 Version strings of the form X.YZ and X.Y.Z-xxxxx are supported. The
420 'xxxxx' part, for instance 'homebrew' on OS/X, is ignored.
421
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700422 Args:
A. Unique TensorFlower28ce1d12017-08-15 12:08:29 -0700423 version: a version to be converted
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700424
425 Returns:
426 An integer if converted successfully, otherwise return None.
427 """
A. Unique TensorFlower28ce1d12017-08-15 12:08:29 -0700428 version = version.split('-')[0]
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700429 version_segments = version.split('.')
430 for seg in version_segments:
431 if not seg.isdigit():
432 return None
433
434 version_str = ''.join(['%03d' % int(seg) for seg in version_segments])
435 return int(version_str)
436
437
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700438def check_bazel_version(min_version):
Yifei Fengdce9a492018-02-22 14:24:57 -0800439 """Check installed bazel version is at least min_version.
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700440
441 Args:
442 min_version: string for minimum bazel version.
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700443
444 Returns:
445 The bazel version detected.
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700446 """
Jonathan Hseu008910f2017-08-25 14:01:05 -0700447 if which('bazel') is None:
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700448 print('Cannot find bazel. Please install bazel.')
449 sys.exit(0)
Shanqing Cai71445712018-03-12 19:33:52 -0700450 curr_version = run_shell(['bazel', '--batch', '--bazelrc=/dev/null', 'version'])
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700451
452 for line in curr_version.split('\n'):
453 if 'Build label: ' in line:
454 curr_version = line.split('Build label: ')[1]
455 break
456
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700457 min_version_int = convert_version_to_int(min_version)
458 curr_version_int = convert_version_to_int(curr_version)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700459
460 # Check if current bazel version can be detected properly.
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700461 if not curr_version_int:
462 print('WARNING: current bazel installation is not a release version.')
463 print('Make sure you are running at least bazel %s' % min_version)
464 return curr_version
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700465
Michael Cased94271a2017-08-22 17:26:52 -0700466 print('You have bazel %s installed.' % curr_version)
A. Unique TensorFlower28ce1d12017-08-15 12:08:29 -0700467
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700468 if curr_version_int < min_version_int:
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700469 print('Please upgrade your bazel installation to version %s or higher to '
470 'build TensorFlow!' % min_version)
471 sys.exit(0)
A. Unique TensorFlower6252d292017-08-04 00:52:34 -0700472 return curr_version
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700473
474
475def set_cc_opt_flags(environ_cp):
476 """Set up architecture-dependent optimization flags.
477
478 Also append CC optimization flags to bazel.rc..
479
480 Args:
481 environ_cp: copy of the os.environ.
482 """
483 if is_ppc64le():
484 # gcc on ppc64le does not support -march, use mcpu instead
485 default_cc_opt_flags = '-mcpu=native'
A. Unique TensorFlower1bba94a2018-04-04 15:45:20 -0700486 elif is_windows():
487 default_cc_opt_flags = '/arch:AVX'
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700488 else:
489 default_cc_opt_flags = '-march=native'
490 question = ('Please specify optimization flags to use during compilation when'
491 ' bazel option "--config=opt" is specified [Default is %s]: '
492 ) % default_cc_opt_flags
493 cc_opt_flags = get_from_env_or_user_or_default(environ_cp, 'CC_OPT_FLAGS',
494 question, default_cc_opt_flags)
495 for opt in cc_opt_flags.split():
Michael Case00177422017-11-10 13:14:03 -0800496 write_to_bazelrc('build:opt --copt=%s' % opt)
497 # It should be safe on the same build host.
A. Unique TensorFlower1bba94a2018-04-04 15:45:20 -0700498 if not is_ppc64le() and not is_windows():
Shanqing Cai71445712018-03-12 19:33:52 -0700499 write_to_bazelrc('build:opt --host_copt=-march=native')
Michael Casebb3355d2017-11-09 08:46:31 -0800500 write_to_bazelrc('build:opt --define with_default_optimizations=true')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700501
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700502def set_tf_cuda_clang(environ_cp):
503 """set TF_CUDA_CLANG action_env.
504
505 Args:
506 environ_cp: copy of the os.environ.
507 """
508 question = 'Do you want to use clang as CUDA compiler?'
509 yes_reply = 'Clang will be used as CUDA compiler.'
510 no_reply = 'nvcc will be used as CUDA compiler.'
511 set_action_env_var(
512 environ_cp,
513 'TF_CUDA_CLANG',
514 None,
515 False,
516 question=question,
517 yes_reply=yes_reply,
518 no_reply=no_reply)
519
520
A. Unique TensorFlowerfd29e952017-12-22 03:07:51 -0800521def set_tf_download_clang(environ_cp):
522 """Set TF_DOWNLOAD_CLANG action_env."""
Ilya Biryukov9e651e42018-03-22 05:33:42 -0700523 question = 'Do you wish to download a fresh release of clang? (Experimental)'
A. Unique TensorFlowerfd29e952017-12-22 03:07:51 -0800524 yes_reply = 'Clang will be downloaded and used to compile tensorflow.'
525 no_reply = 'Clang will not be downloaded.'
526 set_action_env_var(
527 environ_cp,
528 'TF_DOWNLOAD_CLANG',
529 None,
530 False,
531 question=question,
532 yes_reply=yes_reply,
533 no_reply=no_reply)
534
535
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700536def get_from_env_or_user_or_default(environ_cp, var_name, ask_for_var,
537 var_default):
538 """Get var_name either from env, or user or default.
539
540 If var_name has been set as environment variable, use the preset value, else
541 ask for user input. If no input is provided, the default is used.
542
543 Args:
544 environ_cp: copy of the os.environ.
545 var_name: string for name of environment variable, e.g. "TF_NEED_HDFS".
546 ask_for_var: string for how to ask for user input.
547 var_default: default value string.
548
549 Returns:
550 string value for var_name
551 """
552 var = environ_cp.get(var_name)
553 if not var:
554 var = get_input(ask_for_var)
Michael Cased94271a2017-08-22 17:26:52 -0700555 print('\n')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700556 if not var:
557 var = var_default
558 return var
559
560
561def set_clang_cuda_compiler_path(environ_cp):
562 """Set CLANG_CUDA_COMPILER_PATH."""
Jonathan Hseu008910f2017-08-25 14:01:05 -0700563 default_clang_path = which('clang') or ''
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700564 ask_clang_path = ('Please specify which clang should be used as device and '
565 'host compiler. [Default is %s]: ') % default_clang_path
566
567 while True:
568 clang_cuda_compiler_path = get_from_env_or_user_or_default(
569 environ_cp, 'CLANG_CUDA_COMPILER_PATH', ask_clang_path,
570 default_clang_path)
571 if os.path.exists(clang_cuda_compiler_path):
572 break
573
574 # Reset and retry
575 print('Invalid clang path: %s cannot be found.' % clang_cuda_compiler_path)
576 environ_cp['CLANG_CUDA_COMPILER_PATH'] = ''
577
578 # Set CLANG_CUDA_COMPILER_PATH
579 environ_cp['CLANG_CUDA_COMPILER_PATH'] = clang_cuda_compiler_path
580 write_action_env_to_bazelrc('CLANG_CUDA_COMPILER_PATH',
581 clang_cuda_compiler_path)
582
583
Austin Anderson6afface2017-12-05 11:59:17 -0800584def prompt_loop_or_load_from_env(
585 environ_cp,
586 var_name,
587 var_default,
588 ask_for_var,
589 check_success,
590 error_msg,
591 suppress_default_error=False,
592 n_ask_attempts=_DEFAULT_PROMPT_ASK_ATTEMPTS
593):
594 """Loop over user prompts for an ENV param until receiving a valid response.
595
596 For the env param var_name, read from the environment or verify user input
597 until receiving valid input. When done, set var_name in the environ_cp to its
598 new value.
599
600 Args:
601 environ_cp: (Dict) copy of the os.environ.
602 var_name: (String) string for name of environment variable, e.g. "TF_MYVAR".
603 var_default: (String) default value string.
604 ask_for_var: (String) string for how to ask for user input.
605 check_success: (Function) function that takes one argument and returns a
606 boolean. Should return True if the value provided is considered valid. May
607 contain a complex error message if error_msg does not provide enough
608 information. In that case, set suppress_default_error to True.
609 error_msg: (String) String with one and only one '%s'. Formatted with each
610 invalid response upon check_success(input) failure.
611 suppress_default_error: (Bool) Suppress the above error message in favor of
612 one from the check_success function.
613 n_ask_attempts: (Integer) Number of times to query for valid input before
614 raising an error and quitting.
615
616 Returns:
617 [String] The value of var_name after querying for input.
618
619 Raises:
620 UserInputError: if a query has been attempted n_ask_attempts times without
Frank Chenc4ef9272018-01-10 11:36:52 -0800621 success, assume that the user has made a scripting error, and will
622 continue to provide invalid input. Raise the error to avoid infinitely
623 looping.
Austin Anderson6afface2017-12-05 11:59:17 -0800624 """
625 default = environ_cp.get(var_name) or var_default
626 full_query = '%s [Default is %s]: ' % (
627 ask_for_var,
628 default,
629 )
630
631 for _ in range(n_ask_attempts):
632 val = get_from_env_or_user_or_default(environ_cp,
633 var_name,
634 full_query,
635 default)
636 if check_success(val):
637 break
638 if not suppress_default_error:
639 print(error_msg % val)
640 environ_cp[var_name] = ''
641 else:
642 raise UserInputError('Invalid %s setting was provided %d times in a row. '
643 'Assuming to be a scripting mistake.' %
644 (var_name, n_ask_attempts))
645
646 environ_cp[var_name] = val
647 return val
648
649
650def create_android_ndk_rule(environ_cp):
651 """Set ANDROID_NDK_HOME and write Android NDK WORKSPACE rule."""
652 if is_windows() or is_cygwin():
653 default_ndk_path = cygpath('%s/Android/Sdk/ndk-bundle' %
654 environ_cp['APPDATA'])
655 elif is_macos():
656 default_ndk_path = '%s/library/Android/Sdk/ndk-bundle' % environ_cp['HOME']
657 else:
658 default_ndk_path = '%s/Android/Sdk/ndk-bundle' % environ_cp['HOME']
659
660 def valid_ndk_path(path):
661 return (os.path.exists(path) and
662 os.path.exists(os.path.join(path, 'source.properties')))
663
664 android_ndk_home_path = prompt_loop_or_load_from_env(
665 environ_cp,
666 var_name='ANDROID_NDK_HOME',
667 var_default=default_ndk_path,
668 ask_for_var='Please specify the home path of the Android NDK to use.',
669 check_success=valid_ndk_path,
670 error_msg=('The path %s or its child file "source.properties" '
671 'does not exist.')
672 )
Michael Case51053502018-06-05 17:47:19 -0700673 write_action_env_to_bazelrc('ANDROID_NDK_HOME', android_ndk_home_path)
674 write_action_env_to_bazelrc('ANDROID_NDK_API_LEVEL',
675 check_ndk_level(android_ndk_home_path))
Austin Anderson6afface2017-12-05 11:59:17 -0800676
677
678def create_android_sdk_rule(environ_cp):
679 """Set Android variables and write Android SDK WORKSPACE rule."""
680 if is_windows() or is_cygwin():
681 default_sdk_path = cygpath('%s/Android/Sdk' % environ_cp['APPDATA'])
682 elif is_macos():
Shashi Shekharc0ff0cc2018-07-17 09:00:24 -0700683 default_sdk_path = '%s/library/Android/Sdk' % environ_cp['HOME']
Austin Anderson6afface2017-12-05 11:59:17 -0800684 else:
685 default_sdk_path = '%s/Android/Sdk' % environ_cp['HOME']
686
687 def valid_sdk_path(path):
688 return (os.path.exists(path) and
689 os.path.exists(os.path.join(path, 'platforms')) and
690 os.path.exists(os.path.join(path, 'build-tools')))
691
692 android_sdk_home_path = prompt_loop_or_load_from_env(
693 environ_cp,
694 var_name='ANDROID_SDK_HOME',
695 var_default=default_sdk_path,
696 ask_for_var='Please specify the home path of the Android SDK to use.',
697 check_success=valid_sdk_path,
698 error_msg=('Either %s does not exist, or it does not contain the '
699 'subdirectories "platforms" and "build-tools".'))
700
701 platforms = os.path.join(android_sdk_home_path, 'platforms')
702 api_levels = sorted(os.listdir(platforms))
703 api_levels = [x.replace('android-', '') for x in api_levels]
704
705 def valid_api_level(api_level):
706 return os.path.exists(os.path.join(android_sdk_home_path,
707 'platforms',
708 'android-' + api_level))
709
710 android_api_level = prompt_loop_or_load_from_env(
711 environ_cp,
712 var_name='ANDROID_API_LEVEL',
713 var_default=api_levels[-1],
714 ask_for_var=('Please specify the Android SDK API level to use. '
715 '[Available levels: %s]') % api_levels,
716 check_success=valid_api_level,
717 error_msg='Android-%s is not present in the SDK path.')
718
719 build_tools = os.path.join(android_sdk_home_path, 'build-tools')
720 versions = sorted(os.listdir(build_tools))
721
722 def valid_build_tools(version):
723 return os.path.exists(os.path.join(android_sdk_home_path,
724 'build-tools',
725 version))
726
727 android_build_tools_version = prompt_loop_or_load_from_env(
728 environ_cp,
729 var_name='ANDROID_BUILD_TOOLS_VERSION',
730 var_default=versions[-1],
731 ask_for_var=('Please specify an Android build tools version to use. '
732 '[Available versions: %s]') % versions,
733 check_success=valid_build_tools,
734 error_msg=('The selected SDK does not have build-tools version %s '
735 'available.'))
736
Michael Case51053502018-06-05 17:47:19 -0700737 write_action_env_to_bazelrc('ANDROID_BUILD_TOOLS_VERSION',
738 android_build_tools_version)
739 write_action_env_to_bazelrc('ANDROID_SDK_API_LEVEL',
740 android_api_level)
741 write_action_env_to_bazelrc('ANDROID_SDK_HOME',
742 android_sdk_home_path)
Austin Anderson6afface2017-12-05 11:59:17 -0800743
744
745def check_ndk_level(android_ndk_home_path):
746 """Check the revision number of an Android NDK path."""
747 properties_path = '%s/source.properties' % android_ndk_home_path
748 if is_windows() or is_cygwin():
749 properties_path = cygpath(properties_path)
750 with open(properties_path, 'r') as f:
751 filedata = f.read()
752
753 revision = re.search(r'Pkg.Revision = (\d+)', filedata)
754 if revision:
Michael Case51053502018-06-05 17:47:19 -0700755 ndk_api_level = revision.group(1)
756 else:
757 raise Exception('Unable to parse NDK revision.')
758 if int(ndk_api_level) not in _SUPPORTED_ANDROID_NDK_VERSIONS:
759 print('WARNING: The API level of the NDK in %s is %s, which is not '
760 'supported by Bazel (officially supported versions: %s). Please use '
761 'another version. Compiling Android targets may result in confusing '
762 'errors.\n' % (android_ndk_home_path, ndk_api_level,
763 _SUPPORTED_ANDROID_NDK_VERSIONS))
764 return ndk_api_level
Austin Anderson6afface2017-12-05 11:59:17 -0800765
766
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700767def set_gcc_host_compiler_path(environ_cp):
768 """Set GCC_HOST_COMPILER_PATH."""
Jonathan Hseu008910f2017-08-25 14:01:05 -0700769 default_gcc_host_compiler_path = which('gcc') or ''
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700770 cuda_bin_symlink = '%s/bin/gcc' % environ_cp.get('CUDA_TOOLKIT_PATH')
771
772 if os.path.islink(cuda_bin_symlink):
773 # os.readlink is only available in linux
Jonathan Hseu008910f2017-08-25 14:01:05 -0700774 default_gcc_host_compiler_path = os.path.realpath(cuda_bin_symlink)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700775
Austin Anderson6afface2017-12-05 11:59:17 -0800776 gcc_host_compiler_path = prompt_loop_or_load_from_env(
777 environ_cp,
778 var_name='GCC_HOST_COMPILER_PATH',
779 var_default=default_gcc_host_compiler_path,
780 ask_for_var=
781 'Please specify which gcc should be used by nvcc as the host compiler.',
782 check_success=os.path.exists,
783 error_msg='Invalid gcc path. %s cannot be found.',
784 )
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700785
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700786 write_action_env_to_bazelrc('GCC_HOST_COMPILER_PATH', gcc_host_compiler_path)
787
788
Ankur Taly0e6f39d2018-02-16 18:22:55 -0800789def reformat_version_sequence(version_str, sequence_count):
790 """Reformat the version string to have the given number of sequences.
791
792 For example:
793 Given (7, 2) -> 7.0
794 (7.0.1, 2) -> 7.0
795 (5, 1) -> 5
796 (5.0.3.2, 1) -> 5
797
798 Args:
799 version_str: String, the version string.
800 sequence_count: int, an integer.
801 Returns:
802 string, reformatted version string.
803 """
804 v = version_str.split('.')
805 if len(v) < sequence_count:
806 v = v + (['0'] * (sequence_count - len(v)))
807
808 return '.'.join(v[:sequence_count])
809
810
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700811def set_tf_cuda_version(environ_cp):
812 """Set CUDA_TOOLKIT_PATH and TF_CUDA_VERSION."""
813 ask_cuda_version = (
A. Unique TensorFlowerb15500b2018-05-08 12:04:38 -0700814 'Please specify the CUDA SDK version you want to use. '
815 '[Leave empty to default to CUDA %s]: ') % _DEFAULT_CUDA_VERSION
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700816
Austin Andersonf9a88f82017-12-13 11:49:40 -0800817 for _ in range(_DEFAULT_PROMPT_ASK_ATTEMPTS):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700818 # Configure the Cuda SDK version to use.
819 tf_cuda_version = get_from_env_or_user_or_default(
820 environ_cp, 'TF_CUDA_VERSION', ask_cuda_version, _DEFAULT_CUDA_VERSION)
Ankur Taly0e6f39d2018-02-16 18:22:55 -0800821 tf_cuda_version = reformat_version_sequence(str(tf_cuda_version), 2)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700822
823 # Find out where the CUDA toolkit is installed
824 default_cuda_path = _DEFAULT_CUDA_PATH
Martin Wicked57572e2017-09-02 19:21:45 -0700825 if is_windows() or is_cygwin():
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700826 default_cuda_path = cygpath(
827 environ_cp.get('CUDA_PATH', _DEFAULT_CUDA_PATH_WIN))
828 elif is_linux():
829 # If the default doesn't exist, try an alternative default.
830 if (not os.path.exists(default_cuda_path)
831 ) and os.path.exists(_DEFAULT_CUDA_PATH_LINUX):
832 default_cuda_path = _DEFAULT_CUDA_PATH_LINUX
833 ask_cuda_path = ('Please specify the location where CUDA %s toolkit is'
834 ' installed. Refer to README.md for more details. '
835 '[Default is %s]: ') % (tf_cuda_version, default_cuda_path)
836 cuda_toolkit_path = get_from_env_or_user_or_default(
837 environ_cp, 'CUDA_TOOLKIT_PATH', ask_cuda_path, default_cuda_path)
A. Unique TensorFlower02f17fe2018-07-07 06:59:19 -0700838 if is_windows() or is_cygwin():
839 cuda_toolkit_path = cygpath(cuda_toolkit_path)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700840
841 if is_windows():
Niall Moranb7d97e82018-08-09 00:29:49 +0100842 cuda_rt_lib_paths = ['lib/x64/cudart.lib']
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700843 elif is_linux():
Niall Moranb7d97e82018-08-09 00:29:49 +0100844 cuda_rt_lib_paths = ['%s/libcudart.so.%s' % (x, tf_cuda_version)
845 for x in ['lib64', 'lib/x86_64-linux-gnu']]
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700846 elif is_macos():
Niall Moranb7d97e82018-08-09 00:29:49 +0100847 cuda_rt_lib_paths = ['lib/libcudart.%s.dylib' % tf_cuda_version]
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700848
Niall Moranb7d97e82018-08-09 00:29:49 +0100849 cuda_toolkit_paths_full = [os.path.join(cuda_toolkit_path, x) for x in cuda_rt_lib_paths]
850 if any([os.path.exists(x) for x in cuda_toolkit_paths_full]):
Yifei Feng5198cb82018-08-17 13:53:06 -0700851 break
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700852
853 # Reset and retry
854 print('Invalid path to CUDA %s toolkit. %s cannot be found' %
hellcom9a13fc32018-09-12 10:58:24 +0300855 (tf_cuda_version, cuda_toolkit_paths_full))
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700856 environ_cp['TF_CUDA_VERSION'] = ''
857 environ_cp['CUDA_TOOLKIT_PATH'] = ''
858
Austin Andersonf9a88f82017-12-13 11:49:40 -0800859 else:
860 raise UserInputError('Invalid TF_CUDA_SETTING setting was provided %d '
861 'times in a row. Assuming to be a scripting mistake.' %
862 _DEFAULT_PROMPT_ASK_ATTEMPTS)
863
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700864 # Set CUDA_TOOLKIT_PATH and TF_CUDA_VERSION
865 environ_cp['CUDA_TOOLKIT_PATH'] = cuda_toolkit_path
866 write_action_env_to_bazelrc('CUDA_TOOLKIT_PATH', cuda_toolkit_path)
867 environ_cp['TF_CUDA_VERSION'] = tf_cuda_version
868 write_action_env_to_bazelrc('TF_CUDA_VERSION', tf_cuda_version)
869
870
Yifei Fengb1d8c592017-11-22 13:42:21 -0800871def set_tf_cudnn_version(environ_cp):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700872 """Set CUDNN_INSTALL_PATH and TF_CUDNN_VERSION."""
873 ask_cudnn_version = (
Jonathan Hseu008910f2017-08-25 14:01:05 -0700874 'Please specify the cuDNN version you want to use. '
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700875 '[Leave empty to default to cuDNN %s.0]: ') % _DEFAULT_CUDNN_VERSION
876
Austin Andersonf9a88f82017-12-13 11:49:40 -0800877 for _ in range(_DEFAULT_PROMPT_ASK_ATTEMPTS):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700878 tf_cudnn_version = get_from_env_or_user_or_default(
879 environ_cp, 'TF_CUDNN_VERSION', ask_cudnn_version,
880 _DEFAULT_CUDNN_VERSION)
Ankur Taly0e6f39d2018-02-16 18:22:55 -0800881 tf_cudnn_version = reformat_version_sequence(str(tf_cudnn_version), 1)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700882
883 default_cudnn_path = environ_cp.get('CUDA_TOOLKIT_PATH')
884 ask_cudnn_path = (r'Please specify the location where cuDNN %s library is '
885 'installed. Refer to README.md for more details. [Default'
A. Unique TensorFlower1b212352018-07-19 13:48:50 -0700886 ' is %s]: ') % (tf_cudnn_version, default_cudnn_path)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700887 cudnn_install_path = get_from_env_or_user_or_default(
888 environ_cp, 'CUDNN_INSTALL_PATH', ask_cudnn_path, default_cudnn_path)
889
890 # Result returned from "read" will be used unexpanded. That make "~"
891 # unusable. Going through one more level of expansion to handle that.
892 cudnn_install_path = os.path.realpath(
893 os.path.expanduser(cudnn_install_path))
Martin Wicked57572e2017-09-02 19:21:45 -0700894 if is_windows() or is_cygwin():
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700895 cudnn_install_path = cygpath(cudnn_install_path)
896
897 if is_windows():
898 cuda_dnn_lib_path = 'lib/x64/cudnn.lib'
899 cuda_dnn_lib_alt_path = 'lib/x64/cudnn.lib'
900 elif is_linux():
901 cuda_dnn_lib_path = 'lib64/libcudnn.so.%s' % tf_cudnn_version
902 cuda_dnn_lib_alt_path = 'libcudnn.so.%s' % tf_cudnn_version
903 elif is_macos():
904 cuda_dnn_lib_path = 'lib/libcudnn.%s.dylib' % tf_cudnn_version
905 cuda_dnn_lib_alt_path = 'libcudnn.%s.dylib' % tf_cudnn_version
906
907 cuda_dnn_lib_path_full = os.path.join(cudnn_install_path, cuda_dnn_lib_path)
908 cuda_dnn_lib_alt_path_full = os.path.join(cudnn_install_path,
909 cuda_dnn_lib_alt_path)
910 if os.path.exists(cuda_dnn_lib_path_full) or os.path.exists(
911 cuda_dnn_lib_alt_path_full):
912 break
913
914 # Try another alternative for Linux
915 if is_linux():
Jonathan Hseu008910f2017-08-25 14:01:05 -0700916 ldconfig_bin = which('ldconfig') or '/sbin/ldconfig'
917 cudnn_path_from_ldconfig = run_shell([ldconfig_bin, '-p'])
918 cudnn_path_from_ldconfig = re.search('.*libcudnn.so .* => (.*)',
A. Unique TensorFlowere7223582017-09-06 17:57:04 -0700919 cudnn_path_from_ldconfig)
920 if cudnn_path_from_ldconfig:
921 cudnn_path_from_ldconfig = cudnn_path_from_ldconfig.group(1)
922 if os.path.exists('%s.%s' % (cudnn_path_from_ldconfig,
923 tf_cudnn_version)):
924 cudnn_install_path = os.path.dirname(cudnn_path_from_ldconfig)
925 break
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700926
927 # Reset and Retry
928 print(
929 'Invalid path to cuDNN %s toolkit. None of the following files can be '
930 'found:' % tf_cudnn_version)
931 print(cuda_dnn_lib_path_full)
932 print(cuda_dnn_lib_alt_path_full)
933 if is_linux():
934 print('%s.%s' % (cudnn_path_from_ldconfig, tf_cudnn_version))
935
936 environ_cp['TF_CUDNN_VERSION'] = ''
Austin Andersonf9a88f82017-12-13 11:49:40 -0800937 else:
938 raise UserInputError('Invalid TF_CUDNN setting was provided %d '
939 'times in a row. Assuming to be a scripting mistake.' %
940 _DEFAULT_PROMPT_ASK_ATTEMPTS)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -0700941
942 # Set CUDNN_INSTALL_PATH and TF_CUDNN_VERSION
943 environ_cp['CUDNN_INSTALL_PATH'] = cudnn_install_path
944 write_action_env_to_bazelrc('CUDNN_INSTALL_PATH', cudnn_install_path)
945 environ_cp['TF_CUDNN_VERSION'] = tf_cudnn_version
946 write_action_env_to_bazelrc('TF_CUDNN_VERSION', tf_cudnn_version)
947
948
Mingxing Tan1e7b0e42018-06-28 19:13:20 -0700949def is_cuda_compatible(lib, cuda_ver, cudnn_ver):
950 """Check compatibility between given library and cudnn/cudart libraries."""
951 ldd_bin = which('ldd') or '/usr/bin/ldd'
952 ldd_out = run_shell([ldd_bin, lib], True)
953 ldd_out = ldd_out.split(os.linesep)
954 cudnn_pattern = re.compile('.*libcudnn.so\\.?(.*) =>.*$')
955 cuda_pattern = re.compile('.*libcudart.so\\.?(.*) =>.*$')
956 cudnn = None
957 cudart = None
958 cudnn_ok = True # assume no cudnn dependency by default
959 cuda_ok = True # assume no cuda dependency by default
960 for line in ldd_out:
961 if 'libcudnn.so' in line:
962 cudnn = cudnn_pattern.search(line)
963 cudnn_ok = False
964 elif 'libcudart.so' in line:
965 cudart = cuda_pattern.search(line)
966 cuda_ok = False
967 if cudnn and len(cudnn.group(1)):
968 cudnn = convert_version_to_int(cudnn.group(1))
969 if cudart and len(cudart.group(1)):
970 cudart = convert_version_to_int(cudart.group(1))
971 if cudnn is not None:
972 cudnn_ok = (cudnn == cudnn_ver)
973 if cudart is not None:
974 cuda_ok = (cudart == cuda_ver)
975 return cudnn_ok and cuda_ok
976
977
Guangda Lai76f69382018-01-25 23:59:19 -0800978def set_tf_tensorrt_install_path(environ_cp):
979 """Set TENSORRT_INSTALL_PATH and TF_TENSORRT_VERSION.
980
981 Adapted from code contributed by Sami Kama (https://github.com/samikama).
982
983 Args:
984 environ_cp: copy of the os.environ.
985
986 Raises:
987 ValueError: if this method was called under non-Linux platform.
988 UserInputError: if user has provided invalid input multiple times.
989 """
990 if not is_linux():
991 raise ValueError('Currently TensorRT is only supported on Linux platform.')
992
993 # Ask user whether to add TensorRT support.
Mingxing Tan1e7b0e42018-06-28 19:13:20 -0700994 if str(int(get_var(environ_cp, 'TF_NEED_TENSORRT', 'TensorRT',
995 False))) != '1':
Guangda Lai76f69382018-01-25 23:59:19 -0800996 return
997
998 for _ in range(_DEFAULT_PROMPT_ASK_ATTEMPTS):
999 ask_tensorrt_path = (r'Please specify the location where TensorRT is '
1000 'installed. [Default is %s]:') % (
1001 _DEFAULT_TENSORRT_PATH_LINUX)
1002 trt_install_path = get_from_env_or_user_or_default(
1003 environ_cp, 'TENSORRT_INSTALL_PATH', ask_tensorrt_path,
1004 _DEFAULT_TENSORRT_PATH_LINUX)
1005
1006 # Result returned from "read" will be used unexpanded. That make "~"
1007 # unusable. Going through one more level of expansion to handle that.
Mingxing Tan1e7b0e42018-06-28 19:13:20 -07001008 trt_install_path = os.path.realpath(os.path.expanduser(trt_install_path))
Guangda Lai76f69382018-01-25 23:59:19 -08001009
1010 def find_libs(search_path):
1011 """Search for libnvinfer.so in "search_path"."""
1012 fl = set()
1013 if os.path.exists(search_path) and os.path.isdir(search_path):
Mingxing Tan1e7b0e42018-06-28 19:13:20 -07001014 fl.update([
1015 os.path.realpath(os.path.join(search_path, x))
1016 for x in os.listdir(search_path)
1017 if 'libnvinfer.so' in x
1018 ])
Guangda Lai76f69382018-01-25 23:59:19 -08001019 return fl
1020
1021 possible_files = find_libs(trt_install_path)
1022 possible_files.update(find_libs(os.path.join(trt_install_path, 'lib')))
1023 possible_files.update(find_libs(os.path.join(trt_install_path, 'lib64')))
Guangda Lai76f69382018-01-25 23:59:19 -08001024 cuda_ver = convert_version_to_int(environ_cp['TF_CUDA_VERSION'])
1025 cudnn_ver = convert_version_to_int(environ_cp['TF_CUDNN_VERSION'])
1026 nvinfer_pattern = re.compile('.*libnvinfer.so.?(.*)$')
1027 highest_ver = [0, None, None]
1028
1029 for lib_file in possible_files:
Mingxing Tan1e7b0e42018-06-28 19:13:20 -07001030 if is_cuda_compatible(lib_file, cuda_ver, cudnn_ver):
Jacques Pienaar2d0531d2018-03-21 12:07:51 -07001031 matches = nvinfer_pattern.search(lib_file)
1032 if len(matches.groups()) == 0:
1033 continue
1034 ver_str = matches.group(1)
Guangda Lai76f69382018-01-25 23:59:19 -08001035 ver = convert_version_to_int(ver_str) if len(ver_str) else 0
1036 if ver > highest_ver[0]:
1037 highest_ver = [ver, ver_str, lib_file]
1038 if highest_ver[1] is not None:
1039 trt_install_path = os.path.dirname(highest_ver[2])
1040 tf_tensorrt_version = highest_ver[1]
1041 break
1042
1043 # Try another alternative from ldconfig.
1044 ldconfig_bin = which('ldconfig') or '/sbin/ldconfig'
1045 ldconfig_output = run_shell([ldconfig_bin, '-p'])
Mingxing Tan1e7b0e42018-06-28 19:13:20 -07001046 search_result = re.search('.*libnvinfer.so\\.?([0-9.]*).* => (.*)',
1047 ldconfig_output)
Guangda Lai76f69382018-01-25 23:59:19 -08001048 if search_result:
1049 libnvinfer_path_from_ldconfig = search_result.group(2)
1050 if os.path.exists(libnvinfer_path_from_ldconfig):
Mingxing Tan1e7b0e42018-06-28 19:13:20 -07001051 if is_cuda_compatible(libnvinfer_path_from_ldconfig, cuda_ver,
1052 cudnn_ver):
Guangda Lai76f69382018-01-25 23:59:19 -08001053 trt_install_path = os.path.dirname(libnvinfer_path_from_ldconfig)
1054 tf_tensorrt_version = search_result.group(1)
1055 break
1056
1057 # Reset and Retry
Yifei Fengdce9a492018-02-22 14:24:57 -08001058 if possible_files:
1059 print('TensorRT libraries found in one the following directories',
1060 'are not compatible with selected cuda and cudnn installations')
1061 print(trt_install_path)
1062 print(os.path.join(trt_install_path, 'lib'))
1063 print(os.path.join(trt_install_path, 'lib64'))
1064 if search_result:
1065 print(libnvinfer_path_from_ldconfig)
1066 else:
1067 print(
1068 'Invalid path to TensorRT. None of the following files can be found:')
1069 print(trt_install_path)
1070 print(os.path.join(trt_install_path, 'lib'))
1071 print(os.path.join(trt_install_path, 'lib64'))
1072 if search_result:
1073 print(libnvinfer_path_from_ldconfig)
Guangda Lai76f69382018-01-25 23:59:19 -08001074
1075 else:
1076 raise UserInputError('Invalid TF_TENSORRT setting was provided %d '
1077 'times in a row. Assuming to be a scripting mistake.' %
1078 _DEFAULT_PROMPT_ASK_ATTEMPTS)
1079
1080 # Set TENSORRT_INSTALL_PATH and TF_TENSORRT_VERSION
1081 environ_cp['TENSORRT_INSTALL_PATH'] = trt_install_path
1082 write_action_env_to_bazelrc('TENSORRT_INSTALL_PATH', trt_install_path)
1083 environ_cp['TF_TENSORRT_VERSION'] = tf_tensorrt_version
1084 write_action_env_to_bazelrc('TF_TENSORRT_VERSION', tf_tensorrt_version)
1085
1086
A. Unique TensorFlower1fda7642018-04-05 03:09:27 -07001087def set_tf_nccl_install_path(environ_cp):
1088 """Set NCCL_INSTALL_PATH and TF_NCCL_VERSION.
1089
1090 Args:
1091 environ_cp: copy of the os.environ.
1092
1093 Raises:
1094 ValueError: if this method was called under non-Linux platform.
1095 UserInputError: if user has provided invalid input multiple times.
1096 """
1097 if not is_linux():
1098 raise ValueError('Currently NCCL is only supported on Linux platforms.')
1099
1100 ask_nccl_version = (
Smit Hinsu63e6b9b2018-07-13 12:46:24 -07001101 'Please specify the NCCL version you want to use. If NCCL %s is not '
1102 'installed, then you can use version 1.3 that can be fetched '
1103 'automatically but it may have worse performance with multiple GPUs. '
1104 '[Default is %s]: ') % (_DEFAULT_NCCL_VERSION, _DEFAULT_NCCL_VERSION)
A. Unique TensorFlower1fda7642018-04-05 03:09:27 -07001105
1106 for _ in range(_DEFAULT_PROMPT_ASK_ATTEMPTS):
1107 tf_nccl_version = get_from_env_or_user_or_default(
1108 environ_cp, 'TF_NCCL_VERSION', ask_nccl_version, _DEFAULT_NCCL_VERSION)
1109 tf_nccl_version = reformat_version_sequence(str(tf_nccl_version), 1)
1110
1111 if tf_nccl_version == '1':
1112 break # No need to get install path, NCCL 1 is a GitHub repo.
1113
1114 # TODO(csigg): Look with ldconfig first if we can find the library in paths
1115 # like /usr/lib/x86_64-linux-gnu and the header file in the corresponding
1116 # include directory. This is where the NCCL .deb packages install them.
1117 # Then ask the user if we should use that. Instead of a single
1118 # NCCL_INSTALL_PATH, pass separate NCCL_LIB_PATH and NCCL_HDR_PATH to
1119 # nccl_configure.bzl
1120 default_nccl_path = environ_cp.get('CUDA_TOOLKIT_PATH')
1121 ask_nccl_path = (r'Please specify the location where NCCL %s library is '
1122 'installed. Refer to README.md for more details. [Default '
1123 'is %s]:') % (tf_nccl_version, default_nccl_path)
1124 nccl_install_path = get_from_env_or_user_or_default(
1125 environ_cp, 'NCCL_INSTALL_PATH', ask_nccl_path, default_nccl_path)
1126
1127 # Result returned from "read" will be used unexpanded. That make "~"
1128 # unusable. Going through one more level of expansion to handle that.
1129 nccl_install_path = os.path.realpath(os.path.expanduser(nccl_install_path))
1130 if is_windows() or is_cygwin():
1131 nccl_install_path = cygpath(nccl_install_path)
1132
1133 if is_windows():
1134 nccl_lib_path = 'lib/x64/nccl.lib'
1135 elif is_linux():
1136 nccl_lib_path = 'lib/libnccl.so.%s' % tf_nccl_version
1137 elif is_macos():
1138 nccl_lib_path = 'lib/libnccl.%s.dylib' % tf_nccl_version
1139
1140 nccl_lib_path = os.path.join(nccl_install_path, nccl_lib_path)
1141 nccl_hdr_path = os.path.join(nccl_install_path, 'include/nccl.h')
1142 if os.path.exists(nccl_lib_path) and os.path.exists(nccl_hdr_path):
1143 # Set NCCL_INSTALL_PATH
1144 environ_cp['NCCL_INSTALL_PATH'] = nccl_install_path
1145 write_action_env_to_bazelrc('NCCL_INSTALL_PATH', nccl_install_path)
1146 break
1147
1148 # Reset and Retry
1149 print('Invalid path to NCCL %s toolkit, %s or %s not found. Please use the '
1150 'O/S agnostic package of NCCL 2' % (tf_nccl_version, nccl_lib_path,
1151 nccl_hdr_path))
1152
1153 environ_cp['TF_NCCL_VERSION'] = ''
1154 else:
1155 raise UserInputError('Invalid TF_NCCL setting was provided %d '
1156 'times in a row. Assuming to be a scripting mistake.' %
1157 _DEFAULT_PROMPT_ASK_ATTEMPTS)
1158
1159 # Set TF_NCCL_VERSION
1160 environ_cp['TF_NCCL_VERSION'] = tf_nccl_version
1161 write_action_env_to_bazelrc('TF_NCCL_VERSION', tf_nccl_version)
1162
1163
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001164def get_native_cuda_compute_capabilities(environ_cp):
1165 """Get native cuda compute capabilities.
1166
1167 Args:
1168 environ_cp: copy of the os.environ.
1169 Returns:
1170 string of native cuda compute capabilities, separated by comma.
1171 """
1172 device_query_bin = os.path.join(
1173 environ_cp.get('CUDA_TOOLKIT_PATH'), 'extras/demo_suite/deviceQuery')
Jonathan Hseu008910f2017-08-25 14:01:05 -07001174 if os.path.isfile(device_query_bin) and os.access(device_query_bin, os.X_OK):
1175 try:
1176 output = run_shell(device_query_bin).split('\n')
1177 pattern = re.compile('[0-9]*\\.[0-9]*')
1178 output = [pattern.search(x) for x in output if 'Capability' in x]
1179 output = ','.join(x.group() for x in output if x is not None)
1180 except subprocess.CalledProcessError:
1181 output = ''
1182 else:
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001183 output = ''
1184 return output
1185
1186
1187def set_tf_cuda_compute_capabilities(environ_cp):
1188 """Set TF_CUDA_COMPUTE_CAPABILITIES."""
1189 while True:
1190 native_cuda_compute_capabilities = get_native_cuda_compute_capabilities(
1191 environ_cp)
1192 if not native_cuda_compute_capabilities:
1193 default_cuda_compute_capabilities = _DEFAULT_CUDA_COMPUTE_CAPABILITIES
1194 else:
1195 default_cuda_compute_capabilities = native_cuda_compute_capabilities
1196
1197 ask_cuda_compute_capabilities = (
1198 'Please specify a list of comma-separated '
1199 'Cuda compute capabilities you want to '
1200 'build with.\nYou can find the compute '
1201 'capability of your device at: '
1202 'https://developer.nvidia.com/cuda-gpus.\nPlease'
1203 ' note that each additional compute '
1204 'capability significantly increases your '
A. Unique TensorFlower1b212352018-07-19 13:48:50 -07001205 'build time and binary size. [Default is: %s]: ' %
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001206 default_cuda_compute_capabilities)
1207 tf_cuda_compute_capabilities = get_from_env_or_user_or_default(
1208 environ_cp, 'TF_CUDA_COMPUTE_CAPABILITIES',
1209 ask_cuda_compute_capabilities, default_cuda_compute_capabilities)
1210 # Check whether all capabilities from the input is valid
1211 all_valid = True
Maciejd0f5bc12018-04-30 22:30:58 -05001212 # Remove all whitespace characters before splitting the string
Michael Case51053502018-06-05 17:47:19 -07001213 # that users may insert by accident, as this will result in error
Maciejd0f5bc12018-04-30 22:30:58 -05001214 tf_cuda_compute_capabilities = ''.join(tf_cuda_compute_capabilities.split())
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001215 for compute_capability in tf_cuda_compute_capabilities.split(','):
Andrew Harp6e3e7d12017-08-21 12:10:44 -07001216 m = re.match('[0-9]+.[0-9]+', compute_capability)
1217 if not m:
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001218 print('Invalid compute capability: ' % compute_capability)
1219 all_valid = False
Andrew Harp6e3e7d12017-08-21 12:10:44 -07001220 else:
1221 ver = int(m.group(0).split('.')[0])
1222 if ver < 3:
1223 print('Only compute capabilities 3.0 or higher are supported.')
1224 all_valid = False
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001225
1226 if all_valid:
1227 break
1228
1229 # Reset and Retry
1230 environ_cp['TF_CUDA_COMPUTE_CAPABILITIES'] = ''
1231
1232 # Set TF_CUDA_COMPUTE_CAPABILITIES
1233 environ_cp['TF_CUDA_COMPUTE_CAPABILITIES'] = tf_cuda_compute_capabilities
1234 write_action_env_to_bazelrc('TF_CUDA_COMPUTE_CAPABILITIES',
1235 tf_cuda_compute_capabilities)
1236
1237
1238def set_other_cuda_vars(environ_cp):
1239 """Set other CUDA related variables."""
A. Unique TensorFlowerab391982018-07-11 04:52:49 -07001240 # If CUDA is enabled, always use GPU during build and test.
1241 if environ_cp.get('TF_CUDA_CLANG') == '1':
1242 write_to_bazelrc('build --config=cuda_clang')
1243 write_to_bazelrc('test --config=cuda_clang')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001244 else:
A. Unique TensorFlowerab391982018-07-11 04:52:49 -07001245 write_to_bazelrc('build --config=cuda')
1246 write_to_bazelrc('test --config=cuda')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001247
1248
1249def set_host_cxx_compiler(environ_cp):
1250 """Set HOST_CXX_COMPILER."""
Jonathan Hseu008910f2017-08-25 14:01:05 -07001251 default_cxx_host_compiler = which('g++') or ''
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001252
Austin Anderson6afface2017-12-05 11:59:17 -08001253 host_cxx_compiler = prompt_loop_or_load_from_env(
1254 environ_cp,
1255 var_name='HOST_CXX_COMPILER',
1256 var_default=default_cxx_host_compiler,
1257 ask_for_var=('Please specify which C++ compiler should be used as the '
1258 'host C++ compiler.'),
1259 check_success=os.path.exists,
1260 error_msg='Invalid C++ compiler path. %s cannot be found.',
1261 )
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001262
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001263 write_action_env_to_bazelrc('HOST_CXX_COMPILER', host_cxx_compiler)
1264
1265
1266def set_host_c_compiler(environ_cp):
1267 """Set HOST_C_COMPILER."""
Jonathan Hseu008910f2017-08-25 14:01:05 -07001268 default_c_host_compiler = which('gcc') or ''
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001269
Austin Anderson6afface2017-12-05 11:59:17 -08001270 host_c_compiler = prompt_loop_or_load_from_env(
1271 environ_cp,
1272 var_name='HOST_C_COMPILER',
1273 var_default=default_c_host_compiler,
Shanqing Cai71445712018-03-12 19:33:52 -07001274 ask_for_var=('Please specify which C compiler should be used as the host '
Austin Anderson6afface2017-12-05 11:59:17 -08001275 'C compiler.'),
1276 check_success=os.path.exists,
1277 error_msg='Invalid C compiler path. %s cannot be found.',
1278 )
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001279
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001280 write_action_env_to_bazelrc('HOST_C_COMPILER', host_c_compiler)
1281
1282
1283def set_computecpp_toolkit_path(environ_cp):
1284 """Set COMPUTECPP_TOOLKIT_PATH."""
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001285
Austin Anderson6afface2017-12-05 11:59:17 -08001286 def toolkit_exists(toolkit_path):
1287 """Check if a computecpp toolkit path is valid."""
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001288 if is_linux():
1289 sycl_rt_lib_path = 'lib/libComputeCpp.so'
1290 else:
1291 sycl_rt_lib_path = ''
1292
Austin Anderson6afface2017-12-05 11:59:17 -08001293 sycl_rt_lib_path_full = os.path.join(toolkit_path,
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001294 sycl_rt_lib_path)
Austin Anderson6afface2017-12-05 11:59:17 -08001295 exists = os.path.exists(sycl_rt_lib_path_full)
1296 if not exists:
1297 print('Invalid SYCL %s library path. %s cannot be found' %
1298 (_TF_OPENCL_VERSION, sycl_rt_lib_path_full))
1299 return exists
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001300
Austin Anderson6afface2017-12-05 11:59:17 -08001301 computecpp_toolkit_path = prompt_loop_or_load_from_env(
1302 environ_cp,
1303 var_name='COMPUTECPP_TOOLKIT_PATH',
1304 var_default=_DEFAULT_COMPUTECPP_TOOLKIT_PATH,
1305 ask_for_var=(
1306 'Please specify the location where ComputeCpp for SYCL %s is '
1307 'installed.' % _TF_OPENCL_VERSION),
1308 check_success=toolkit_exists,
1309 error_msg='Invalid SYCL compiler path. %s cannot be found.',
1310 suppress_default_error=True)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001311
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001312 write_action_env_to_bazelrc('COMPUTECPP_TOOLKIT_PATH',
1313 computecpp_toolkit_path)
1314
Michael Cased31531a2018-01-05 14:09:41 -08001315
Dandelion Man?90e42f32017-12-15 18:15:07 -08001316def set_trisycl_include_dir(environ_cp):
Michael Cased31531a2018-01-05 14:09:41 -08001317 """Set TRISYCL_INCLUDE_DIR."""
Frank Chenc4ef9272018-01-10 11:36:52 -08001318
Dandelion Man?90e42f32017-12-15 18:15:07 -08001319 ask_trisycl_include_dir = ('Please specify the location of the triSYCL '
1320 'include directory. (Use --config=sycl_trisycl '
1321 'when building with Bazel) '
1322 '[Default is %s]: '
Michael Cased31531a2018-01-05 14:09:41 -08001323 ) % (_DEFAULT_TRISYCL_INCLUDE_DIR)
Frank Chenc4ef9272018-01-10 11:36:52 -08001324
Dandelion Man?90e42f32017-12-15 18:15:07 -08001325 while True:
1326 trisycl_include_dir = get_from_env_or_user_or_default(
Michael Cased31531a2018-01-05 14:09:41 -08001327 environ_cp, 'TRISYCL_INCLUDE_DIR', ask_trisycl_include_dir,
1328 _DEFAULT_TRISYCL_INCLUDE_DIR)
Dandelion Man?90e42f32017-12-15 18:15:07 -08001329 if os.path.exists(trisycl_include_dir):
1330 break
1331
1332 print('Invalid triSYCL include directory, %s cannot be found'
1333 % (trisycl_include_dir))
1334
1335 # Set TRISYCL_INCLUDE_DIR
1336 environ_cp['TRISYCL_INCLUDE_DIR'] = trisycl_include_dir
1337 write_action_env_to_bazelrc('TRISYCL_INCLUDE_DIR',
1338 trisycl_include_dir)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001339
Yifei Fengb1d8c592017-11-22 13:42:21 -08001340
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001341def set_mpi_home(environ_cp):
1342 """Set MPI_HOME."""
Austin Anderson6afface2017-12-05 11:59:17 -08001343
Jonathan Hseu008910f2017-08-25 14:01:05 -07001344 default_mpi_home = which('mpirun') or which('mpiexec') or ''
1345 default_mpi_home = os.path.dirname(os.path.dirname(default_mpi_home))
1346
Austin Anderson6afface2017-12-05 11:59:17 -08001347 def valid_mpi_path(mpi_home):
1348 exists = (os.path.exists(os.path.join(mpi_home, 'include')) and
1349 os.path.exists(os.path.join(mpi_home, 'lib')))
1350 if not exists:
1351 print('Invalid path to the MPI Toolkit. %s or %s cannot be found' %
1352 (os.path.join(mpi_home, 'include'),
1353 os.path.exists(os.path.join(mpi_home, 'lib'))))
1354 return exists
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001355
Austin Anderson6afface2017-12-05 11:59:17 -08001356 _ = prompt_loop_or_load_from_env(
1357 environ_cp,
1358 var_name='MPI_HOME',
1359 var_default=default_mpi_home,
1360 ask_for_var='Please specify the MPI toolkit folder.',
1361 check_success=valid_mpi_path,
1362 error_msg='',
1363 suppress_default_error=True)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001364
1365
1366def set_other_mpi_vars(environ_cp):
1367 """Set other MPI related variables."""
1368 # Link the MPI header files
1369 mpi_home = environ_cp.get('MPI_HOME')
1370 symlink_force('%s/include/mpi.h' % mpi_home, 'third_party/mpi/mpi.h')
1371
1372 # Determine if we use OpenMPI or MVAPICH, these require different header files
1373 # to be included here to make bazel dependency checker happy
1374 if os.path.exists(os.path.join(mpi_home, 'include/mpi_portable_platform.h')):
1375 symlink_force(
1376 os.path.join(mpi_home, 'include/mpi_portable_platform.h'),
1377 'third_party/mpi/mpi_portable_platform.h')
1378 # TODO(gunan): avoid editing files in configure
1379 sed_in_place('third_party/mpi/mpi.bzl', 'MPI_LIB_IS_OPENMPI=False',
1380 'MPI_LIB_IS_OPENMPI=True')
1381 else:
1382 # MVAPICH / MPICH
1383 symlink_force(
1384 os.path.join(mpi_home, 'include/mpio.h'), 'third_party/mpi/mpio.h')
1385 symlink_force(
1386 os.path.join(mpi_home, 'include/mpicxx.h'), 'third_party/mpi/mpicxx.h')
1387 # TODO(gunan): avoid editing files in configure
1388 sed_in_place('third_party/mpi/mpi.bzl', 'MPI_LIB_IS_OPENMPI=True',
1389 'MPI_LIB_IS_OPENMPI=False')
1390
1391 if os.path.exists(os.path.join(mpi_home, 'lib/libmpi.so')):
1392 symlink_force(
1393 os.path.join(mpi_home, 'lib/libmpi.so'), 'third_party/mpi/libmpi.so')
1394 else:
1395 raise ValueError('Cannot find the MPI library file in %s/lib' % mpi_home)
1396
1397
A. Unique TensorFlower061c3592017-11-13 14:21:04 -08001398def set_grpc_build_flags():
1399 write_to_bazelrc('build --define grpc_no_ares=true')
1400
Michael Cased31531a2018-01-05 14:09:41 -08001401
Yifei Feng5198cb82018-08-17 13:53:06 -07001402def set_system_libs_flag(environ_cp):
1403 syslibs = environ_cp.get('TF_SYSTEM_LIBS', '')
Yifei Feng5198cb82018-08-17 13:53:06 -07001404 if syslibs and syslibs != '':
Jason Zaman5fc39bd2018-09-16 01:38:55 +08001405 if ',' in syslibs:
1406 syslibs = ','.join(sorted(syslibs.split(',')))
1407 else:
1408 syslibs = ','.join(sorted(syslibs.split()))
Yifei Feng5198cb82018-08-17 13:53:06 -07001409 write_action_env_to_bazelrc('TF_SYSTEM_LIBS', syslibs)
1410
Jason Zaman5fc39bd2018-09-16 01:38:55 +08001411 if 'PREFIX' in environ_cp:
1412 write_to_bazelrc('build --define=PREFIX=%s' % environ_cp['PREFIX'])
1413 if 'LIBDIR' in environ_cp:
1414 write_to_bazelrc('build --define=LIBDIR=%s' % environ_cp['LIBDIR'])
1415 if 'INCLUDEDIR' in environ_cp:
1416 write_to_bazelrc('build --define=INCLUDEDIR=%s' % environ_cp['INCLUDEDIR'])
1417
Yifei Feng5198cb82018-08-17 13:53:06 -07001418
A. Unique TensorFlower1b212352018-07-19 13:48:50 -07001419def set_windows_build_flags(environ_cp):
1420 """Set Windows specific build options."""
1421 # The non-monolithic build is not supported yet
1422 write_to_bazelrc('build --config monolithic')
1423 # Suppress warning messages
1424 write_to_bazelrc('build --copt=-w --host_copt=-w')
1425 # Output more verbose information when something goes wrong
1426 write_to_bazelrc('build --verbose_failures')
1427 # The host and target platforms are the same in Windows build. So we don't
1428 # have to distinct them. This avoids building the same targets twice.
1429 write_to_bazelrc('build --distinct_host_configuration=false')
1430 # Enable short object file path to avoid long path issue on Windows.
1431 # TODO(pcloudy): Remove this flag when upgrading Bazel to 0.16.0
1432 # Short object file path will be enabled by default.
1433 write_to_bazelrc('build --experimental_shortened_obj_file_path=true')
1434
1435 if get_var(
1436 environ_cp, 'TF_OVERRIDE_EIGEN_STRONG_INLINE', 'Eigen strong inline',
1437 True,
1438 ('Would you like to override eigen strong inline for some C++ '
A. Unique TensorFlower8ed40cd2018-07-20 10:55:31 -07001439 'compilation to reduce the compilation time?'),
A. Unique TensorFlower1b212352018-07-19 13:48:50 -07001440 'Eigen strong inline overridden.',
1441 'Not overriding eigen strong inline, '
1442 'some compilations could take more than 20 mins.'):
1443 # Due to a known MSVC compiler issue
1444 # https://github.com/tensorflow/tensorflow/issues/10521
1445 # Overriding eigen strong inline speeds up the compiling of
1446 # conv_grad_ops_3d.cc and conv_ops_3d.cc by 20 minutes,
1447 # but this also hurts the performance. Let users decide what they want.
1448 write_to_bazelrc('build --define=override_eigen_strong_inline=true')
Dandelion Man?90e42f32017-12-15 18:15:07 -08001449
A. Unique TensorFlower061c3592017-11-13 14:21:04 -08001450
Michael Cased31531a2018-01-05 14:09:41 -08001451def config_info_line(name, help_text):
1452 """Helper function to print formatted help text for Bazel config options."""
1453 print('\t--config=%-12s\t# %s' % (name, help_text))
1454
1455
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001456def main():
Shanqing Cai71445712018-03-12 19:33:52 -07001457 parser = argparse.ArgumentParser()
1458 parser.add_argument("--workspace",
1459 type=str,
1460 default=_TF_WORKSPACE_ROOT,
1461 help="The absolute path to your active Bazel workspace.")
1462 args = parser.parse_args()
1463
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001464 # Make a copy of os.environ to be clear when functions and getting and setting
1465 # environment variables.
1466 environ_cp = dict(os.environ)
1467
Yifei Fengbb384112018-07-24 13:12:54 -07001468 check_bazel_version('0.15.0')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001469
Shanqing Cai71445712018-03-12 19:33:52 -07001470 reset_tf_configure_bazelrc(args.workspace)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001471 cleanup_makefile()
Gunhan Gulsoyed89a2b2017-09-19 18:36:26 -07001472 setup_python(environ_cp)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001473
1474 if is_windows():
Yong Tanga7b7aa82018-07-02 07:41:42 -07001475 environ_cp['TF_NEED_AWS'] = '0'
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001476 environ_cp['TF_NEED_GCP'] = '0'
1477 environ_cp['TF_NEED_HDFS'] = '0'
1478 environ_cp['TF_NEED_JEMALLOC'] = '0'
Michael Cased90054e2018-02-07 14:36:00 -08001479 environ_cp['TF_NEED_KAFKA'] = '0'
Yifei Fengb1d8c592017-11-22 13:42:21 -08001480 environ_cp['TF_NEED_OPENCL_SYCL'] = '0'
1481 environ_cp['TF_NEED_COMPUTECPP'] = '0'
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001482 environ_cp['TF_NEED_OPENCL'] = '0'
1483 environ_cp['TF_CUDA_CLANG'] = '0'
Guangda Lai76f69382018-01-25 23:59:19 -08001484 environ_cp['TF_NEED_TENSORRT'] = '0'
Ilya Biryukov9e651e42018-03-22 05:33:42 -07001485 # TODO(ibiryukov): Investigate using clang as a cpu or cuda compiler on
1486 # Windows.
1487 environ_cp['TF_DOWNLOAD_CLANG'] = '0'
A. Unique TensorFlower6e97fb32018-07-16 14:07:29 -07001488 environ_cp['TF_ENABLE_XLA'] = '0'
1489 environ_cp['TF_NEED_GDR'] = '0'
1490 environ_cp['TF_NEED_VERBS'] = '0'
1491 environ_cp['TF_NEED_MPI'] = '0'
1492 environ_cp['TF_SET_ANDROID_WORKSPACE'] = '0'
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001493
1494 if is_macos():
1495 environ_cp['TF_NEED_JEMALLOC'] = '0'
Guangda Lai76f69382018-01-25 23:59:19 -08001496 environ_cp['TF_NEED_TENSORRT'] = '0'
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001497
Jon Triebenbach6896a742018-06-27 13:29:53 -05001498 # The numpy package on ppc64le uses OpenBLAS which has multi-threading
1499 # issues that lead to incorrect answers. Set OMP_NUM_THREADS=1 at
1500 # runtime to allow the Tensorflow testcases which compare numpy
1501 # results to Tensorflow results to succeed.
1502 if is_ppc64le():
1503 write_action_env_to_bazelrc("OMP_NUM_THREADS", 1)
1504
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001505 set_build_var(environ_cp, 'TF_NEED_JEMALLOC', 'jemalloc as malloc',
1506 'with_jemalloc', True)
1507 set_build_var(environ_cp, 'TF_NEED_GCP', 'Google Cloud Platform',
Benoit Steiner355e25e2017-10-24 19:47:46 -07001508 'with_gcp_support', True, 'gcp')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001509 set_build_var(environ_cp, 'TF_NEED_HDFS', 'Hadoop File System',
Benoit Steiner355e25e2017-10-24 19:47:46 -07001510 'with_hdfs_support', True, 'hdfs')
Yong Tanga7b7aa82018-07-02 07:41:42 -07001511 set_build_var(environ_cp, 'TF_NEED_AWS', 'Amazon AWS Platform',
1512 'with_aws_support', True, 'aws')
Michael Cased90054e2018-02-07 14:36:00 -08001513 set_build_var(environ_cp, 'TF_NEED_KAFKA', 'Apache Kafka Platform',
Jianwei Xie63dffd52018-03-29 10:50:46 -07001514 'with_kafka_support', True, 'kafka')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001515 set_build_var(environ_cp, 'TF_ENABLE_XLA', 'XLA JIT', 'with_xla_support',
Michael Case98850a52017-09-14 13:35:57 -07001516 False, 'xla')
A. Unique TensorFlower28ce1d12017-08-15 12:08:29 -07001517 set_build_var(environ_cp, 'TF_NEED_GDR', 'GDR', 'with_gdr_support',
Michael Case98850a52017-09-14 13:35:57 -07001518 False, 'gdr')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001519 set_build_var(environ_cp, 'TF_NEED_VERBS', 'VERBS', 'with_verbs_support',
Michael Case98850a52017-09-14 13:35:57 -07001520 False, 'verbs')
Avijitf88a6f92018-07-24 23:58:58 -07001521 set_build_var(environ_cp, 'TF_NEED_NGRAPH', 'nGraph',
1522 'with_ngraph_support', False, 'ngraph')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001523
Yifei Fengb1d8c592017-11-22 13:42:21 -08001524 set_action_env_var(environ_cp, 'TF_NEED_OPENCL_SYCL', 'OpenCL SYCL', False)
1525 if environ_cp.get('TF_NEED_OPENCL_SYCL') == '1':
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001526 set_host_cxx_compiler(environ_cp)
1527 set_host_c_compiler(environ_cp)
Yifei Fengb1d8c592017-11-22 13:42:21 -08001528 set_action_env_var(environ_cp, 'TF_NEED_COMPUTECPP', 'ComputeCPP', True)
1529 if environ_cp.get('TF_NEED_COMPUTECPP') == '1':
1530 set_computecpp_toolkit_path(environ_cp)
1531 else:
1532 set_trisycl_include_dir(environ_cp)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001533
1534 set_action_env_var(environ_cp, 'TF_NEED_CUDA', 'CUDA', False)
A. Unique TensorFlower24cbb2a2017-09-08 07:45:44 -07001535 if (environ_cp.get('TF_NEED_CUDA') == '1' and
1536 'TF_CUDA_CONFIG_REPO' not in environ_cp):
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001537 set_tf_cuda_version(environ_cp)
Yifei Fengb1d8c592017-11-22 13:42:21 -08001538 set_tf_cudnn_version(environ_cp)
Guangda Lai76f69382018-01-25 23:59:19 -08001539 if is_linux():
1540 set_tf_tensorrt_install_path(environ_cp)
Michael Case0073d132018-04-11 09:34:44 -07001541 set_tf_nccl_install_path(environ_cp)
1542
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001543 set_tf_cuda_compute_capabilities(environ_cp)
Ankur Taly0e6f39d2018-02-16 18:22:55 -08001544 if 'LD_LIBRARY_PATH' in environ_cp and environ_cp.get(
1545 'LD_LIBRARY_PATH') != '1':
1546 write_action_env_to_bazelrc('LD_LIBRARY_PATH',
1547 environ_cp.get('LD_LIBRARY_PATH'))
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001548
1549 set_tf_cuda_clang(environ_cp)
1550 if environ_cp.get('TF_CUDA_CLANG') == '1':
Ilya Biryukov9e651e42018-03-22 05:33:42 -07001551 # Ask whether we should download the clang toolchain.
1552 set_tf_download_clang(environ_cp)
A. Unique TensorFlowerfd29e952017-12-22 03:07:51 -08001553 if environ_cp.get('TF_DOWNLOAD_CLANG') != '1':
1554 # Set up which clang we should use as the cuda / host compiler.
1555 set_clang_cuda_compiler_path(environ_cp)
Ilya Biryukov1c3d02e2018-09-04 03:09:52 -07001556 else:
1557 # Use downloaded LLD for linking.
1558 write_to_bazelrc('build:cuda_clang --config=download_clang_use_lld')
1559 write_to_bazelrc('test:cuda_clang --config=download_clang_use_lld')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001560 else:
1561 # Set up which gcc nvcc should use as the host compiler
1562 # No need to set this on Windows
1563 if not is_windows():
1564 set_gcc_host_compiler_path(environ_cp)
1565 set_other_cuda_vars(environ_cp)
Ilya Biryukov9e651e42018-03-22 05:33:42 -07001566 else:
1567 # CUDA not required. Ask whether we should download the clang toolchain and
1568 # use it for the CPU build.
1569 set_tf_download_clang(environ_cp)
1570 if environ_cp.get('TF_DOWNLOAD_CLANG') == '1':
1571 write_to_bazelrc('build --config=download_clang')
1572 write_to_bazelrc('test --config=download_clang')
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001573
1574 set_build_var(environ_cp, 'TF_NEED_MPI', 'MPI', 'with_mpi_support', False)
1575 if environ_cp.get('TF_NEED_MPI') == '1':
1576 set_mpi_home(environ_cp)
1577 set_other_mpi_vars(environ_cp)
1578
A. Unique TensorFlower061c3592017-11-13 14:21:04 -08001579 set_grpc_build_flags()
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001580 set_cc_opt_flags(environ_cp)
Yifei Feng5198cb82018-08-17 13:53:06 -07001581 set_system_libs_flag(environ_cp)
A. Unique TensorFlower1b212352018-07-19 13:48:50 -07001582 if is_windows():
1583 set_windows_build_flags(environ_cp)
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001584
Anna Ra9a1d5a2018-09-14 12:44:31 -07001585 # Add a config option to build TensorFlow 2.0 API.
1586 write_to_bazelrc('build:v2 --define=tf_api_version=2')
1587
Michael Case51053502018-06-05 17:47:19 -07001588 if get_var(
1589 environ_cp, 'TF_SET_ANDROID_WORKSPACE', 'android workspace',
1590 False,
1591 ('Would you like to interactively configure ./WORKSPACE for '
1592 'Android builds?'),
1593 'Searching for NDK and SDK installations.',
1594 'Not configuring the WORKSPACE for Android builds.'):
1595 create_android_ndk_rule(environ_cp)
1596 create_android_sdk_rule(environ_cp)
Austin Anderson6afface2017-12-05 11:59:17 -08001597
A. Unique TensorFlower1b212352018-07-19 13:48:50 -07001598 # On Windows, we don't have MKL support and the build is always monolithic.
1599 # So no need to print the following message.
1600 # TODO(pcloudy): remove the following if check when they make sense on Windows
1601 if not is_windows():
1602 print('Preconfigured Bazel build configs. You can use any of the below by '
1603 'adding "--config=<>" to your build command. See tools/bazel.rc for '
1604 'more details.')
1605 config_info_line('mkl', 'Build with MKL support.')
1606 config_info_line('monolithic', 'Config for mostly static monolithic build.')
Austin Anderson6afface2017-12-05 11:59:17 -08001607
A. Unique TensorFlower73ea2872017-07-25 13:30:03 -07001608if __name__ == '__main__':
1609 main()