162 lines
6.4 KiB
Python
Executable File
162 lines
6.4 KiB
Python
Executable File
#!/usr/bin/python
|
|
|
|
|
|
#-------------------------------------------------------------------------------#
|
|
# android-cmake and android-ndk based build script for conformance
|
|
#-------------------------------------------------------------------------------#
|
|
"""
|
|
Dependencies:
|
|
|
|
1) android-ndk version android-ndk-r10d or higher is required. Further, the environment
|
|
variable ANDROID_NDK should be defined to point to it.
|
|
|
|
2) android-cmake should be installed (else the script can install it for you). If installed,
|
|
the environment variable ANDROID_CMAKE should point to install location, unless it is in the current
|
|
working directory in which case it is picked up by default.
|
|
|
|
3) CL_INCLUDE_DIR should be defined to point to CL headers. Alternately, this can be provided
|
|
as an input (-I)
|
|
|
|
4) Path to opencl library to link against (libOpenCL.so) can be provided using -L. If this isn't
|
|
available the script will try to use CL_LIB_DIR_64 or CL_LIB_DIR_32 environment variables -
|
|
if available - to pick up the right library for the architecture being built.
|
|
|
|
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import argparse
|
|
import time
|
|
import shlex
|
|
|
|
start = time.time()
|
|
script = os.path.basename( sys.argv[ 0 ] )
|
|
|
|
def die (msg):
|
|
print msg
|
|
exit(-1)
|
|
|
|
def execute (cmdline):
|
|
retcode = subprocess.call(cmdline)
|
|
if retcode != 0:
|
|
raise Exception("Failed to execute '%s', got %d" % (commandLine, retcode))
|
|
|
|
def build(args):
|
|
if not (args.testDir):
|
|
print("building...")
|
|
execute("make")
|
|
else:
|
|
if os.path.exists( os.path.join(args.bld_dir, "test_conformance", args.testDir) ):
|
|
os.chdir( os.path.join("test_conformance",args.testDir) )
|
|
print("Building test: %s..." %args.testDir)
|
|
execute("make")
|
|
os.chdir(args.bld_dir)
|
|
else:
|
|
print ("Error: %s test doesn't exist" %args.testDir)
|
|
|
|
|
|
def configure (args):
|
|
print("configuring...")
|
|
cmdline = []
|
|
cmdline.extend(['cmake', "-DCMAKE_TOOLCHAIN_FILE=" + os.path.join(args.android_cmake,"android.toolchain.cmake")])
|
|
for var in args.cmake_defs :
|
|
cmdline.extend([ '-D', var ])
|
|
cmdline.extend(['-DCL_INCLUDE_DIR=' + args.inc_dir])
|
|
cmdline.extend(['-DCL_LIB_DIR=' + args.lib_dir])
|
|
cmdline.extend(['-DANDROID_NATIVE_API_LEVEL=' + "android-21"])
|
|
if args.arch == "64":
|
|
cmdline.extend(['-DANDROID_ABI=arm64-v8a'])
|
|
cmdline.extend(['-DANDROID_SO_UNDEFINED=ON'])
|
|
cmdline.extend([args.src_dir])
|
|
execute(cmdline)
|
|
|
|
def check_var (parser, args, name):
|
|
if not(args.__dict__[name]):
|
|
parser.error("%s needs to be defined" % name)
|
|
|
|
def print_config(args):
|
|
print("----------CONFIGURATION--------------\n")
|
|
print("android_cmake: %s" % args.android_cmake)
|
|
print("android_ndk: %s" % args.android_ndk)
|
|
print("lib_dir: %s" % args.lib_dir)
|
|
print("inc_dir: %s" % args.inc_dir)
|
|
if len(args.cmake_defs):
|
|
print("cmake options:" + "\n:".join( [ " `%s'" % dir for dir in args.cmake_defs ] ))
|
|
print("architecture: %s" % args.arch)
|
|
print("-------------------------------------\n")
|
|
|
|
def get_input():
|
|
yes = set(['yes','y', 'ye', ''])
|
|
no = set(['no','n'])
|
|
|
|
choice = raw_input().lower()
|
|
if choice in yes:
|
|
return True
|
|
elif choice in no:
|
|
return False
|
|
else:
|
|
sys.stdout.write("Please respond with 'yes' or 'no'")
|
|
exit()
|
|
|
|
def install_android_cmake():
|
|
parser.print_help()
|
|
print "\nandroid-cmake doesn't seem to be installed - It should be provided as a) cmdline input b) environment variable $ANDROID_CMAKE or c) present in the current directory\n"
|
|
print "if you would like to download and install it in the current directory please enter yes\n"
|
|
print "if you would like to provide an environment variable($ANDROID_CMAKE) or command-line input(--android_cmake) rerun the script enter no\n"
|
|
print "input: "
|
|
if get_input():
|
|
print("installing android-cmake")
|
|
#subprocess.call(['git', 'clone', 'https://github.com/taka-no-me/android-cmake'])
|
|
# Use a newer fork of android-cmake which has been updated to support Clang. GCC is deprecated in newer NDKs and C11 atomics conformance doesn't build with NDK > 10.
|
|
subprocess.call(['git', 'clone', 'https://github.com/daewoong-jang/android-cmake'])
|
|
args.android_cmake = os.path.join(args.src_dir,"android-cmake")
|
|
else:
|
|
exit()
|
|
|
|
try:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('--android_cmake', dest='android_cmake', default=os.environ.get('ANDROID_CMAKE'), help="Path to android-cmake (can also be set using environment variable $ANDROID_CMAKE).")
|
|
parser.add_argument('--android_ndk', dest='android_ndk', default=os.environ.get('ANDROID_NDK'), help="Path to android-ndk (can also be set using environment variable $ANDROID_NDK).")
|
|
parser.add_argument('-L','--lib_dir', dest='lib_dir', default="", help="Path to libOpenCL to link against (can also be set using environment variable $CL_LIB_DIR_32 and $CL_LIB_DIR_64).")
|
|
parser.add_argument('-I','--include_dir', dest='inc_dir', default=os.environ.get('CL_INCLUDE_DIR'), help="Path to headers (can also be set using environment variable $CL_INCLUDE_DIR).")
|
|
parser.add_argument('-D', dest='cmake_defs', action='append', default=[], help="Define CMAKE variable")
|
|
parser.add_argument('-a','--arch', default="32", help="Architecture to build for (32 or 64)")
|
|
parser.add_argument('-t','--test', dest='testDir', default="", help="Builds the given test")
|
|
|
|
args = parser.parse_args()
|
|
|
|
args.src_dir = os.path.realpath(os.path.dirname( sys.argv[ 0 ]))
|
|
|
|
if not (args.android_cmake):
|
|
if os.path.exists(os.path.join(args.src_dir,"android-cmake")):
|
|
args.android_cmake = os.path.join(args.src_dir,"android-cmake")
|
|
else:
|
|
install_android_cmake()
|
|
|
|
if not (args.lib_dir):
|
|
lib_var_name = "CL_LIB_DIR_" + ("32" if (args.arch == "32") else "64")
|
|
args.lib_dir = os.environ.get(lib_var_name)
|
|
|
|
check_var(parser, args, "android_cmake")
|
|
check_var(parser, args, "lib_dir")
|
|
check_var(parser, args, "inc_dir")
|
|
check_var(parser, args, "android_ndk")
|
|
|
|
print_config(args)
|
|
|
|
args.bld_dir = os.path.join(args.src_dir, 'bld_android_%s' % args.arch)
|
|
if not os.path.exists(args.bld_dir):
|
|
os.makedirs(args.bld_dir)
|
|
os.chdir(args.bld_dir)
|
|
|
|
configure(args)
|
|
build(args)
|
|
|
|
sys.exit( 0 )
|
|
|
|
finally:
|
|
finish = time.time()
|
|
print("Elapsed time: %.0f s." % ( finish - start ) )
|