def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
abis = []
for arch in arches:
abis.extend(build_support.arch_to_abis(arch))
print('Building stlport for ABIs: {}'.format(' '.join(abis)))
abis_arg = '--abis={}'.format(','.join(abis))
ndk_dir_arg = '--ndk-dir={}'.format(build_support.ndk_path())
script = build_support.ndk_path('build/tools/build-cxx-stl.sh')
build_cmd = [
'bash',
script,
'--stl=stlport',
abis_arg,
ndk_dir_arg,
build_support.jobs_arg(),
build_support.toolchain_path(),
'--with-debug-info',
'--llvm-version=3.6',
]
build_support.build(build_cmd, args)
def main(args):
GCC_VERSION = "4.9"
toolchains = build_support.ALL_TOOLCHAINS
if args.toolchain is not None:
toolchains = [args.toolchain]
print("Building {} toolchains: {}".format(args.host, " ".join(toolchains)))
for toolchain in toolchains:
toolchain_name = "-".join([toolchain, GCC_VERSION])
sysroot_arg = "--sysroot={}".format(build_support.sysroot_path(toolchain))
build_cmd = [
"bash",
"build-gcc.sh",
build_support.toolchain_path(),
build_support.ndk_path(),
toolchain_name,
build_support.jobs_arg(),
sysroot_arg,
]
if args.host in ("windows", "windows64"):
build_cmd.append("--mingw")
if args.host != "windows":
build_cmd.append("--try-64")
build_support.build(build_cmd, args)
def main(args):
GCC_VERSION = '4.9'
toolchains = build_support.ALL_TOOLCHAINS
if args.toolchain is not None:
toolchains = [args.toolchain]
print('Building {} toolchains: {}'.format(args.host, ' '.join(toolchains)))
for toolchain in toolchains:
toolchain_name = '-'.join([toolchain, GCC_VERSION])
sysroot_arg = '--sysroot={}'.format(
build_support.sysroot_path(toolchain))
build_cmd = [
'bash',
'build-gcc.sh',
build_support.toolchain_path(),
build_support.ndk_path(),
toolchain_name,
build_support.jobs_arg(),
sysroot_arg,
]
if args.host in ('windows', 'windows64'):
build_cmd.append('--mingw')
if args.host != 'windows':
build_cmd.append('--try-64')
build_support.build(build_cmd, args)
def main():
pm = bs.ProjectMap()
sd = pm.project_source_dir(pm.current_project())
if os.path.exists(os.path.join(sd, 'meson.build')):
meson_build()
else:
bs.build(MesaBuilder())
def main():
global_opts = bs.Options()
options = []
if global_opts.arch == "m32":
# m32 build not supported
return
options = options + [
"--enable-gbm", "--enable-llvm", "--with-egl-platforms=x11,drm",
"--enable-glx-tls", "--enable-gles1", "--enable-gles2",
"--with-gallium-drivers=svga,swrast,r300,r600,radeonsi,nouveau",
"--with-vulkan-drivers=intel,radeon"
]
if global_opts.config == 'debug':
options.append('--enable-debug')
# builder = bs.AutoBuilder(configure_options=options, export=False)
builder = NoTest(configure_options=options)
save_dir = os.getcwd()
try:
bs.build(builder)
except subprocess.CalledProcessError as e:
# build may have taken us to a place where ProjectMap doesn't work
os.chdir(save_dir)
bs.Export().create_failing_test("mesa-buildtest", str(e))
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
abis = []
for arch in arches:
abis.extend(build_support.arch_to_abis(arch))
build_dir = os.path.join(args.out_dir, 'gnustl')
print('Building libstdc++ for ABIs: {}'.format(' '.join(abis)))
abis_arg = '--abis={}'.format(','.join(abis))
ndk_dir_arg = '--ndk-dir={}'.format(build_support.ndk_path())
build_cmd = [
'bash',
'build-gnu-libstdc++.sh',
abis_arg,
ndk_dir_arg,
build_support.jobs_arg(),
build_support.toolchain_path(),
'--with-debug-info',
'--build-dir={}'.format(build_dir),
]
build_support.build(build_cmd, args)
def main(args):
GCC_VERSION = '4.9'
toolchains = build_support.ALL_TOOLCHAINS
if args.toolchain is not None:
toolchains = [args.toolchain]
print(f'Building {args.host.value} toolchains: {" ".join(toolchains)}')
for toolchain in toolchains:
toolchain_name = '-'.join([toolchain, GCC_VERSION])
sysroot_arg = '--sysroot={}'.format(
build_support.sysroot_path(toolchain))
build_cmd = [
'bash',
'build-gcc.sh',
build_support.toolchain_path(),
build_support.ndk_path(),
toolchain_name,
build_support.jobs_arg(),
sysroot_arg,
'--try-64',
]
if args.host.is_windows:
build_cmd.append('--mingw')
build_support.build(build_cmd, args)
def main():
global_opts = bs.Options()
options = []
if global_opts.arch == "m32":
# m32 build not supported
return
options = options + ["--enable-gbm",
"--with-egl-platforms=x11,drm",
"--enable-glx-tls",
"--enable-gles1",
"--enable-gles2",
"--with-gallium-drivers=i915,svga,swrast,r300,r600,radeonsi,nouveau"]
if global_opts.config == 'debug':
options.append('--enable-debug')
# builder = bs.AutoBuilder(configure_options=options, export=False)
builder = NoTest(configure_options=options)
save_dir = os.getcwd()
try:
bs.build(builder)
except subprocess.CalledProcessError as e:
# build may have taken us to a place where ProjectMap doesn't work
os.chdir(save_dir)
bs.Export().create_failing_test("mesa-buildtest", str(e))
def main():
b = SconsBuilder()
save_dir = os.getcwd()
try:
bs.build(b)
except subprocess.CalledProcessError as e:
# build may have taken us to a place where ProjectMap doesn't work
os.chdir(save_dir)
bs.Export().create_failing_test("mesa-scons-buildtest", str(e))
def main():
b = SconsBuilder()
save_dir = os.getcwd()
try:
bs.build(b)
except subprocess.CalledProcessError as e:
# build may have taken us to a place where ProjectMap doesn't work
os.chdir(save_dir)
bs.Export().create_failing_test("mesa-scons-buildtest", str(e))
def main(args):
if args.host not in ("windows", "windows64"):
sys.exit("Toolbox is only for Windows hosts.")
build_cmd = ["bash", "build-toolbox.sh"]
if args.host != "windows":
build_cmd.append("--try-64")
build_support.build(build_cmd, args, intermediate_package=True)
def main():
# Disable test if using < Mesa 18.0
pm = bs.ProjectMap()
sd = pm.project_source_dir("mesa")
if not os.path.exists(os.path.join(sd,
'src/mesa/drivers/osmesa/meson.build')):
return 0
bs.build(bs.AndroidBuilder(src_location="~/android-ia",
module="libGLES_mesa"))
def meson_build():
global_opts = bs.Options()
options = [
'-Detnaviv=true',
'-Dfreedreno=true',
]
if global_opts.config != 'debug':
options.extend(['-Dbuildtype=release', '-Db_ndebug=true'])
b = bs.builders.MesonBuilder(extra_definitions=options, install=True)
bs.build(b)
def main(args):
if args.host not in ('windows', 'windows64'):
sys.exit('Toolbox is only for Windows hosts.')
build_cmd = [
'bash', 'build-toolbox.sh',
]
if args.host != 'windows':
build_cmd.append('--try-64')
build_support.build(build_cmd, args, intermediate_package=True)
def main(args):
build_cmd = [
'bash', 'build-make.sh',
]
if args.host in ('windows', 'windows64'):
build_cmd.append('--mingw')
if args.host != 'windows':
build_cmd.append('--try-64')
build_support.build(build_cmd, args, intermediate_package=True)
def main(args):
build_cmd = [
'bash',
'build-make.sh',
]
if args.host in ('windows', 'windows64'):
build_cmd.append('--mingw')
if args.host != 'windows':
build_cmd.append('--try-64')
build_support.build(build_cmd, args, intermediate_package=True)
def main(args):
src_dir_arg = '--src-dir={}'.format(build_support.toolchain_path())
build_cmd = [
'bash', 'build-ndk-depends.sh', src_dir_arg,
]
if args.host in ('windows', 'windows64'):
build_cmd.append('--mingw')
if args.host != 'windows':
build_cmd.append('--try-64')
build_support.build(build_cmd, args, intermediate_package=True)
def main():
global_opts = bs.Options()
options = []
if global_opts.arch == "m32":
# expat pkg-config fails for some reason on i386
options = ['EXPAT_LIBS="-L/usr/lib/i386-linux-gnu -lexpat"']
surfaceless = ""
if path.exists(bs.ProjectMap().project_source_dir() + "/src/egl/drivers/dri2/platform_surfaceless.c"):
# surfaceless not supported on 10.6 and earlier
surfaceless = ",surfaceless"
options = options + ["--enable-gbm",
"--with-egl-platforms=x11,drm" + surfaceless,
"--enable-glx-tls",
"--enable-gles1",
"--enable-gles2",
"--with-dri-drivers=i965,swrast,i915",
# disable video drivers:
# bbe6f7f865cd4316b5f885507ee0b128a20686eb
# caused build failure unrelated to intel mesa
# team.
"--disable-xvmc",
"--disable-vdpau",
# gallium tested with mesa-buildtest
"--without-gallium-drivers"]
if global_opts.config == 'debug':
options.append('--enable-debug')
# always enable optimizations in mesa because tests are too slow
# without them.
builder = bs.AutoBuilder(configure_options=options, opt_flags="-O2")
gtests = ["src/glsl/tests/general-ir-test",
"src/glsl/tests/sampler-types-test",
"src/glsl/tests/uniform-initializer-test",
"src/glx/tests/glx-test",
"src/mesa/main/tests/main-test",
"src/mesa/drivers/dri/i965/test_vec4_copy_propagation",
"src/mesa/drivers/dri/i965/test_vec4_register_coalesce",
"./src/mapi/shared-glapi-test"]
builder.AddGtests(gtests)
bs.build(builder)
def main(args):
src_dir_arg = '--src-dir={}'.format(build_support.toolchain_path())
build_cmd = [
'bash', 'build-ndk-stack.sh', src_dir_arg,
]
if args.host in ('windows', 'windows64'):
build_cmd.append('--mingw')
if args.host != 'windows':
build_cmd.append('--try-64')
build_cmd.append('--build-dir=' + os.path.join(args.out_dir, 'ndk-stack'))
build_support.build(build_cmd, args)
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
print('Building plaforms: {}'.format(' '.join(arches)))
arch_arg = '--arch={}'.format(','.join(arches))
ndk_dir_arg = '--ndk-dir={}'.format(build_support.ndk_path())
build_cmd = [
'bash', 'gen-platforms.sh', '--fast-copy', arch_arg, ndk_dir_arg,
]
if args.host != 'linux':
build_cmd.append('--case-insensitive')
build_support.build(build_cmd, args)
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
print('Building gdbservers: {}'.format(' '.join(arches)))
for arch in arches:
build_dir = os.path.join(args.out_dir, 'gdbserver', arch)
target_triple = dict(zip(
build_support.ALL_ARCHITECTURES, GDBSERVER_TARGETS))[arch]
build_cmd = [
'bash', 'build-gdbserver.sh', arch, target_triple,
build_support.toolchain_path(), build_support.ndk_path(),
'--build-out={}'.format(build_dir), build_support.jobs_arg(),
]
build_support.build(build_cmd, args)
def main(args):
GCC_VERSION = '4.9'
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
print('Building gdbservers: {}'.format(' '.join(arches)))
for arch in arches:
toolchain = build_support.arch_to_toolchain(arch)
toolchain_name = '-'.join([toolchain, GCC_VERSION])
build_cmd = [
'bash', 'build-gdbserver.sh', build_support.toolchain_path(),
build_support.ndk_path(), toolchain_name, build_support.jobs_arg(),
]
build_support.build(build_cmd, args)
def meson_build():
global_opts = bs.Options()
options = [
'-Dgallium-drivers=',
'-Ddri-drivers=i965,i915',
'-Dvulkan-drivers=intel',
'-Dplatforms=x11,drm',
]
cpp_args = None
if global_opts.config == 'debug':
cpp_args = "-DDEBUG"
else:
options.extend(['-Dbuildtype=release', '-Db_ndebug=true'])
b = bs.builders.MesonBuilder(extra_definitions=options,
install=True,
cpp_args=cpp_args)
bs.build(b)
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
print('Building plaforms: {}'.format(' '.join(arches)))
arch_arg = '--arch={}'.format(','.join(arches))
ndk_dir_arg = '--ndk-dir={}'.format(build_support.ndk_path())
build_cmd = [
'bash',
'gen-platforms.sh',
'--fast-copy',
arch_arg,
ndk_dir_arg,
]
if args.host != 'linux':
build_cmd.append('--case-insensitive')
build_support.build(build_cmd, args)
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
print('Building gdbservers: {}'.format(' '.join(arches)))
for arch in arches:
target_triple = dict(
zip(build_support.ALL_ARCHITECTURES, GDBSERVER_TARGETS))[arch]
build_cmd = [
'bash',
'build-gdbserver.sh',
arch,
target_triple,
build_support.toolchain_path(),
build_support.ndk_path(),
build_support.jobs_arg(),
]
build_support.build(build_cmd, args)
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
abis = []
for arch in arches:
abis.extend(build_support.arch_to_abis(arch))
print('Building libc++ for ABIs: {}'.format(' '.join(abis)))
abis_arg = '--abis={}'.format(','.join(abis))
ndk_dir_arg = '--ndk-dir={}'.format(build_support.ndk_path())
script = build_support.ndk_path('build/tools/build-cxx-stl.sh')
build_cmd = [
'bash', script, '--stl=libc++-libc++abi', abis_arg, ndk_dir_arg,
build_support.jobs_arg(), build_support.toolchain_path(),
'--with-debug-info', '--llvm-version=3.6',
]
build_support.build(build_cmd, args)
def main(args):
GCC_VERSION = '4.9'
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
print('Building gdbservers: {}'.format(' '.join(arches)))
for arch in arches:
toolchain = build_support.arch_to_toolchain(arch)
toolchain_name = '-'.join([toolchain, GCC_VERSION])
build_cmd = [
'bash',
'build-gdbserver.sh',
build_support.toolchain_path(),
build_support.ndk_path(),
toolchain_name,
build_support.jobs_arg(),
]
build_support.build(build_cmd, args)
def main(args):
arches = build_support.ALL_ARCHITECTURES
if args.arch is not None:
arches = [args.arch]
abis = []
for arch in arches:
abis.extend(build_support.arch_to_abis(arch))
print("Building libstdc++ for ABIs: {}".format(" ".join(abis)))
abis_arg = "--abis={}".format(",".join(abis))
ndk_dir_arg = "--ndk-dir={}".format(build_support.ndk_path())
build_cmd = [
"bash",
"build-gnu-libstdc++.sh",
abis_arg,
ndk_dir_arg,
build_support.jobs_arg(),
build_support.toolchain_path(),
"--with-debug-info",
]
build_support.build(build_cmd, args)
#!/usr/bin/python
import sys, os
sys.path.append(
os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
class DrmBuilder(bs.AutoBuilder):
def __init__(self):
bs.AutoBuilder.__init__(self)
def test(self):
# libdrm now has a 2-minute long test, which is too long to
# wait for.
pass
bs.build(DrmBuilder())
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(
path.join(path.dirname(path.abspath(sys.argv[0])), "..", "repos",
"mesa_ci"))
import build_support as bs
bs.build(bs.PerfBuilder("gfxbench5.alu2_o", iterations=5))
#!/usr/bin/python import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "..")) import build_support as bs bs.build(bs.AutoBuilder())
save_dir = os.getcwd()
bd = self._build_dir + "/skl"
if not os.path.exists(bd):
os.makedirs(bd)
os.chdir(bd)
flags = " ".join(self._flags)
flags = [
"CFLAGS=-O2 " + flags, "CXXFLAGS=-O2 " + flags, "CC=ccache gcc",
"CXX=ccache g++"
]
cmd = [self._src_dir + "/autogen.sh"] + flags + options
bs.run_batch_command(cmd)
bs.run_batch_command(
["make", "-j", str(bs.cpu_count()), "install"],
env={"DESTDIR": "/tmp/build_root/" + self.opts.arch + "/bxt"})
os.chdir(save_dir)
bs.Export().export_perf()
def clean(self):
pm = bs.ProjectMap()
bs.git_clean(pm.project_source_dir("mesa"))
bs.rmtree(self._build_dir)
def test(self):
pass
bs.build(MesaPerf())
#!/usr/bin/python
import os
import sys
import time
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
# HACK
# repeatedly invoking build() will overwrite the start times. Record
# it now and write the correct value when the last build() has
# finished. build() was not intended to be used this way.
start_time = time.time()
bs.build(bs.PiglitTester(_suite="cpu", device_override="byt"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="g45"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="g965"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="ilk"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="ivbgt2"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="snbgt2"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="hswgt3"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="bdwgt2"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="sklgt3"))
bs.build(bs.PiglitTester(_suite="cpu", device_override="bsw"))
options = bs.Options()
if (options.result_path):
bs.ProjectInvoke(options).set_info("start_time", start_time)
#!/usr/bin/python
import sys, os
sys.path.append(
os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
opts = [
'-DPIGLIT_BUILD_DMA_BUF_TESTS=1',
'-DPIGLIT_BUILD_GLES1_TESTS=1',
'-DPIGLIT_BUILD_GLES2_TESTS=1',
'-DPIGLIT_BUILD_GLES3_TESTS=1',
'-DPIGLIT_BUILD_GL_TESTS=1',
'-DPIGLIT_BUILD_GLX_TESTS=1',
'-DPIGLIT_BUILD_CL_TESTS=0',
]
builder = bs.CMakeBuilder(extra_definitions=opts)
bs.build(builder)
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), ".."))
import build_support as bs
def iterations(_, hw):
if hw == "bdw":
return 30
class XonoticTimeout:
def __init__(self):
self._options = bs.Options()
def GetDuration(self):
base_time = 20
if "bsw" in self._options.hardware:
base_time = base_time * 2
if self._options.type == "daily":
base_time = base_time * 5
return base_time
bs.build(bs.PerfBuilder("xonotic", iterations=20,
custom_iterations_fn=iterations),
time_limit=XonoticTimeout())
self.hardware = bs.Options().hardware
def GetDuration(self):
if self.hardware == "bsw":
return 120
if self.hardware == "byt":
return 120
if self.hardware == "g33":
return 120
if self.hardware == "g965":
return 50
# all other test suites finish in 10 minutes or less.
# TODO: put back to 25 when curro's regression is fixed
return 40
# add the --piglit_test option to the standard options. Parse the
# options, and strip the piglit_test so the options will work as usual
# for subsequent objects.
o = bs.CustomOptions("piglit args allow a specific test")
o.add_argument(arg='--piglit_test', type=str, default="",
help="single piglit test to run.")
o.parse_args()
piglit_test = ""
if o.piglit_test:
piglit_test = o.piglit_test
bs.build(bs.PiglitTester(_suite="gpu",
piglit_test=piglit_test),
time_limit=SlowTimeout())
os.chdir(self._build_dir)
bs.run_batch_command(cmd)
bs.run_batch_command(["ninja", "vk-build-programs"])
save_dir = os.getcwd()
os.chdir("external/vulkancts/modules/vulkan")
out_dir = os.path.join(self._src_dir, "external", "vulkancts", "data", "vulkan", "prebuilt")
print "Pre-building spir-v binaries: vk-build-programs -d " + out_dir
bs.run_batch_command(["./vk-build-programs", "-d", out_dir],
quiet=True,
streamedOutput=False)
os.chdir(save_dir)
bs.run_batch_command(["ninja"])
bin_dir = self._build_root + "/opt/deqp/"
if not os.path.exists(bin_dir):
os.makedirs(bin_dir)
bs.run_batch_command(["rsync", "-rlptD",
self._build_dir + "/external/vulkancts/modules",
bin_dir])
bs.Export().export()
def clean(self):
bs.git_clean(self._src_dir)
def test(self):
pass
if __name__ == "__main__":
bs.build(VulkanCtsBuilder())
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), ".."))
import build_support as bs
def iterations(_, hw):
if hw == "bdw":
return 30
bs.build(bs.PerfBuilder("fur", iterations=10,
custom_iterations_fn=iterations))
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(
path.join(path.dirname(path.abspath(sys.argv[0])), "..", "repos",
"mesa_ci"))
import build_support as bs
bs.build(bs.PerfBuilder("gfxbench5.car_chase_o", iterations=5))
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), "..", "repos", "mesa_ci"))
import build_support as bs
bs.build(bs.PerfBuilder("gfxbench5.driver2_o", iterations=5))
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), ".."))
import build_support as bs
class WarsowTimeout:
def __init__(self):
self._options = bs.Options()
def GetDuration(self):
base_time = 20
if "bsw" in self._options.hardware:
base_time = base_time * 2
if self._options.type == "daily":
base_time = base_time * 5
return base_time
bs.build(bs.PerfBuilder("warsow", iterations=15,
env={"allow_glsl_extension_directive_midshader":"true"}),
time_limit=WarsowTimeout())
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), ".."))
import build_support as bs
bs.build(bs.PerfBuilder("trex_o", iterations=10))
if apass.attrib["status"] != "pass":
continue
if apass.find("failure") is not None:
continue
out_tag = apass.find("system-out")
if out_tag is not None:
apass.remove(out_tag)
err_tag = apass.find("system-err")
if err_tag is not None and err_tag.text is not None:
found = False
for a_line in err_tag.text.splitlines():
m = re.match("pid: ([0-9]+)", a_line)
if m is not None:
found = True
err_tag.text = a_line
break
if not found:
apass.remove(err_tag)
t.write(outfile)
class SlowTimeout:
def __init__(self):
self.hardware = bs.Options().hardware
def GetDuration(self):
return 500
bs.build(CtsBuilder(), time_limit=SlowTimeout())
os.makedirs(self._build_dir)
savedir = os.getcwd()
os.chdir(self._build_dir)
cflag = "-m32"
cxxflag = "-m32"
if self._options.arch == "m64":
cflag = "-m64"
cxxflag = "-m64"
env = {"CC":"ccache gcc",
"CXX":"ccache g++",
"CFLAGS":cflag,
"CXXFLAGS":cxxflag}
self._options.update_env(env)
bs.run_batch_command(["cmake", "-GNinja", self._src_dir] + self._extra_definitions,
env=env)
bs.run_batch_command(["ninja","-j" + str(bs.cpu_count())], env=env)
bs.run_batch_command(["mkdir", "-p", pm.build_root() + "/bin"])
bs.run_batch_command(["cp", "-a", self._build_dir + "/cts",
pm.build_root() + "/bin"])
os.chdir(savedir)
bs.Export().export()
bs.build(CtsBuilder())
#!/usr/bin/python import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "..")) import build_support as bs bs.build(bs.CtsBuilder(suite="es"))
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), ".."))
import build_support as bs
bs.build(bs.PerfBuilder("trex_o", iterations=5))
#!/usr/bin/python
import sys
import os
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
class SlowTimeout:
def __init__(self):
pass
def GetDuration(self):
return 500
bs.build(bs.DeqpBuilder(["vk"]), time_limit=SlowTimeout())
#!/usr/bin/python
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
bs.build(bs.CMakeBuilder(extra_definitions=["-Dwaffle_has_x11_egl=1",
"-Dwaffle_has_glx=1",
"-Dwaffle_has_gbm=1"
] ))
btype = "Release"
if self._options.type == "debug":
btype = "RelDeb"
flags = "-m64"
if self._options.arch == "m32":
flags = "-m32"
cmd = [
"cmake", "-GNinja", "-DCMAKE_BUILD_TYPE=" + btype,
"-DSHADERC_SKIP_TESTS=1", "-DCMAKE_C_FLAGS=" + flags,
"-DCMAKE_CXX_FLAGS=" + flags,
"-DCMAKE_INSTALL_PREFIX:PATH=" + self._build_root, ".."
]
bs.run_batch_command(cmd)
bs.run_batch_command(["ninja"])
bin_dir = self._build_root + "/bin/"
if not os.path.exists(bin_dir):
os.makedirs(bin_dir)
bs.run_batch_command(
["cp", "-a", "-n", self._build_dir + "/glslc/glslc", bin_dir])
bs.Export().export()
def clean(self):
bs.git_clean(self._src_dir)
def test(self):
pass
bs.build(ShadercBuilder())
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(path.join(path.dirname(path.abspath(sys.argv[0])), ".."))
import build_support as bs
bs.build(bs.PerfBuilder("trex", iterations=15))
"library_path": "/tmp/build_root/%s/lib/libvulkan_intel.so",
"abi_versions": "1.0.3"
}
}
""" % self._options.arch
if not os.path.exists(os.path.dirname(icd_path)):
os.makedirs(os.path.dirname(icd_path))
with open(icd_path, "w") as icd_f:
icd_f.write(icd_content)
def test(self):
gtests = ["src/glx/tests/glx-test",
"src/mesa/main/tests/main-test",
"src/mesa/drivers/dri/i965/test_vec4_copy_propagation",
"src/mesa/drivers/dri/i965/test_vec4_register_coalesce",
"./src/mapi/shared-glapi-test"]
# override the test method, because we can't know exactly
# where the tests will be as of 11.2
if path.exists(self._src_dir + "/src/glsl/tests/general_ir_test.cpp"):
gtests += ["src/glsl/tests/general-ir-test",
"src/glsl/tests/sampler-types-test",
"src/glsl/tests/uniform-initializer-test"]
else:
gtests += ["src/compiler/glsl/tests/general-ir-test",
"src/compiler/glsl/tests/sampler-types-test",
"src/compiler/glsl/tests/uniform-initializer-test"]
self.SetGtests(gtests)
bs.AutoBuilder.test(self)
bs.build(MesaBuilder())
#!/usr/bin/python
import sys, os
sys.path.append(
os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "..", "repos",
"mesa_ci"))
import build_support as bs
bs.build(
bs.CMakeBuilder(extra_definitions=[
"-Dwaffle_has_x11_egl=1",
"-Dwaffle_has_glx=1",
"-Dwaffle_has_gbm=1",
"-Dwaffle_has_wayland=0",
]))
#!/usr/bin/python
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
class DrmBuilder(bs.AutoBuilder):
def __init__(self):
bs.AutoBuilder.__init__(self)
def test(self):
# libdrm now has a 2-minute long test, which is too long to
# wait for.
pass
bs.build(DrmBuilder())
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(
path.join(path.dirname(path.abspath(sys.argv[0])), "..", "repos",
"mesa_ci"))
import build_support as bs
bs.build(bs.PerfBuilder("gfxbench5.car_chase_o", iterations=5, windowed=True))
def clean(self):
pass
def test(self):
pm = bs.ProjectMap()
global_opts = bs.Options()
if global_opts.arch == "m64":
icd_name = "intel_icd.x86_64.json"
elif global_opts.arch == "m32":
icd_name = "intel_icd.i686.json"
env = {"VK_ICD_FILENAMES" : pm.build_root() + \
"/share/vulkan/icd.d/" + icd_name,
"ANV_ABORT_ON_DEVICE_LOSS" : "true"}
tester = bs.DeqpTester()
binary = pm.build_root() + "/opt/deqp/modules/vulkan/deqp-vk"
results = tester.test(binary,
VulkanTestList(), ["--deqp-surface-type=fbo"],
env=env)
o = bs.Options()
mv = bs.mesa_version()
if "glk" in o.hardware and "13.0" in mv:
print "WARNING: glk not supported by stable mesa"
return
config = bs.get_conf_file(o.hardware,
o.arch,
project=pm.current_project())
tester.generate_results(results, bs.ConfigFilter(config, o))
bs.build(VulkanTester(), time_limit=SlowTimeout())
#!/usr/bin/python
import sys, os
sys.path.append(
os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
bs.build(bs.CtsBuilder(suite="es"))
#!/usr/bin/python
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), ".."))
import build_support as bs
opts = [
'-DPIGLIT_BUILD_DMA_BUF_TESTS=1',
'-DPIGLIT_BUILD_GLES1_TESTS=1',
'-DPIGLIT_BUILD_GLES2_TESTS=1',
'-DPIGLIT_BUILD_GLES3_TESTS=1',
'-DPIGLIT_BUILD_GL_TESTS=1',
'-DPIGLIT_BUILD_GLX_TESTS=1',
'-DPIGLIT_BUILD_CL_TESTS=0',
]
builder = bs.CMakeBuilder(extra_definitions=opts)
bs.build(builder)
#!/usr/bin/python
import os
import sys
import os.path as path
sys.path.append(
path.join(path.dirname(path.abspath(sys.argv[0])), "..", "repos",
"mesa_ci"))
import build_support as bs
bs.build(bs.PerfBuilder("gfxbench5.fill_o", iterations=5, windowed=True))
#!/usr/bin/python import sys, os sys.path.append(os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), "..")) import build_support as bs bs.build(bs.CMakeBuilder(extra_definitions=["-DDEQP_TARGET=x11_glx"]))
