Merge vk-gl-cts/vulkan-cts-1.0.1 into vk-gl-cts/vulkan-cts-1.0.2
[platform/upstream/VK-GL-CTS.git] / scripts / check_build_sanity.py
1 # -*- coding: utf-8 -*-
2
3 #-------------------------------------------------------------------------
4 # drawElements Quality Program utilities
5 # --------------------------------------
6 #
7 # Copyright 2016 The Android Open Source Project
8 #
9 # Licensed under the Apache License, Version 2.0 (the "License");
10 # you may not use this file except in compliance with the License.
11 # You may obtain a copy of the License at
12 #
13 #      http://www.apache.org/licenses/LICENSE-2.0
14 #
15 # Unless required by applicable law or agreed to in writing, software
16 # distributed under the License is distributed on an "AS IS" BASIS,
17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 # See the License for the specific language governing permissions and
19 # limitations under the License.
20 #
21 #-------------------------------------------------------------------------
22
23 import os
24 import argparse
25 import tempfile
26
27 from build.common import *
28 from build.build import *
29
30 class Environment:
31         def __init__ (self, srcDir, tmpDir):
32                 self.srcDir     = srcDir
33                 self.tmpDir     = tmpDir
34
35 class BuildTestStep:
36         def getName (self):
37                 return "<unknown>"
38
39         def isAvailable (self, env):
40                 return True
41
42         def run (self, env):
43                 raise Exception("Not implemented")
44
45 class RunScript(BuildTestStep):
46         def __init__ (self, scriptPath, getExtraArgs = None):
47                 self.scriptPath         = scriptPath
48                 self.getExtraArgs       = getExtraArgs
49
50         def getName (self):
51                 return self.scriptPath
52
53         def run (self, env):
54                 args = ["python", os.path.join(env.srcDir, self.scriptPath)]
55
56                 if self.getExtraArgs != None:
57                         args += self.getExtraArgs(env)
58
59                 execute(args)
60
61 def makeCflagsArgs (cflags):
62         cflagsStr = " ".join(cflags)
63         return ["-DCMAKE_C_FLAGS=%s" % cflagsStr, "-DCMAKE_CXX_FLAGS=%s" % cflagsStr]
64
65 def makeBuildArgs (target, cc, cpp, cflags):
66         return ["-DDEQP_TARGET=%s" % target, "-DCMAKE_C_COMPILER=%s" % cc, "-DCMAKE_CXX_COMPILER=%s" % cpp] + makeCflagsArgs(cflags)
67
68 class BuildConfigGen:
69         def isAvailable (self, env):
70                 return True
71
72 class UnixConfig(BuildConfigGen):
73         def __init__ (self, target, buildType, cc, cpp, cflags):
74                 self.target             = target
75                 self.buildType  = buildType
76                 self.cc                 = cc
77                 self.cpp                = cpp
78                 self.cflags             = cflags
79
80         def isAvailable (self, env):
81                 return which(self.cc) != None and which(self.cpp) != None
82
83         def getBuildConfig (self, env, buildDir):
84                 args = makeBuildArgs(self.target, self.cc, self.cpp, self.cflags)
85                 return BuildConfig(buildDir, self.buildType, args, env.srcDir)
86
87 class VSConfig(BuildConfigGen):
88         def __init__ (self, buildType):
89                 self.buildType = buildType
90
91         def getBuildConfig (self, env, buildDir):
92                 args = ["-DCMAKE_C_FLAGS=/WX -DCMAKE_CXX_FLAGS=/WX"]
93                 return BuildConfig(buildDir, self.buildType, args, env.srcDir)
94
95 class Build(BuildTestStep):
96         def __init__ (self, buildDir, configGen, generator):
97                 self.buildDir   = buildDir
98                 self.configGen  = configGen
99                 self.generator  = generator
100
101         def getName (self):
102                 return self.buildDir
103
104         def isAvailable (self, env):
105                 return self.configGen.isAvailable(env) and self.generator != None and self.generator.isAvailable()
106
107         def run (self, env):
108                 # specialize config for env
109                 buildDir        = os.path.join(env.tmpDir, self.buildDir)
110                 curConfig       = self.configGen.getBuildConfig(env, buildDir)
111
112                 build(curConfig, self.generator)
113
114 class CheckSrcChanges(BuildTestStep):
115         def getName (self):
116                 return "check for changes"
117
118         def run (self, env):
119                 pushWorkingDir(env.srcDir)
120                 execute(["git", "diff", "--exit-code"])
121                 popWorkingDir()
122
123 def getClangVersion ():
124         knownVersions = ["4.0", "3.9", "3.8", "3.7", "3.6", "3.5"]
125         for version in knownVersions:
126                 if which("clang-" + version) != None:
127                         return "-" + version
128         return ""
129
130 def runSteps (steps):
131         for step in steps:
132                 if step.isAvailable(env):
133                         print "Run: %s" % step.getName()
134                         step.run(env)
135                 else:
136                         print "Skip: %s" % step.getName()
137
138 def runRecipe (steps):
139         allSteps = PREREQUISITES + steps + POST_CHECKS
140         runSteps(allSteps)
141
142 COMMON_GCC_CFLAGS       = ["-Werror"]
143 COMMON_CLANG_CFLAGS     = COMMON_GCC_CFLAGS + ["-Wno-error=unused-command-line-argument"]
144 GCC_32BIT_CFLAGS        = COMMON_GCC_CFLAGS + ["-m32"]
145 CLANG_32BIT_CFLAGS      = COMMON_CLANG_CFLAGS + ["-m32"]
146 GCC_64BIT_CFLAGS        = COMMON_GCC_CFLAGS + ["-m64"]
147 CLANG_64BIT_CFLAGS      = COMMON_CLANG_CFLAGS + ["-m64"]
148 CLANG_VERSION           = getClangVersion()
149
150 # Always ran before any receipe
151 PREREQUISITES           = [
152         RunScript(os.path.join("external", "fetch_sources.py"))
153 ]
154
155 # Always ran after any receipe
156 POST_CHECKS                     = [
157         CheckSrcChanges()
158 ]
159
160 BUILD_TARGETS           = [
161         Build("clang-64-debug",
162                   UnixConfig("null",
163                                          "Debug",
164                                          "clang" + CLANG_VERSION,
165                                          "clang++" + CLANG_VERSION,
166                                          CLANG_64BIT_CFLAGS),
167                   ANY_UNIX_GENERATOR),
168         Build("gcc-32-debug",
169                   UnixConfig("null",
170                                          "Debug",
171                                          "gcc",
172                                          "g++",
173                                          GCC_32BIT_CFLAGS),
174                   ANY_UNIX_GENERATOR),
175         Build("gcc-64-release",
176                   UnixConfig("null",
177                                          "Release",
178                                          "gcc",
179                                          "g++",
180                                          GCC_64BIT_CFLAGS),
181                   ANY_UNIX_GENERATOR),
182         Build("vs-64-debug",
183                   VSConfig("Debug"),
184                   ANY_VS_X64_GENERATOR),
185 ]
186
187 SPECIAL_RECIPES         = [
188         ('android-mustpass', [
189                         RunScript(os.path.join("scripts", "build_android_mustpass.py"),
190                                           lambda env: ["--build-dir", os.path.join(env.tmpDir, "android-mustpass")]),
191                 ]),
192         ('vulkan-mustpass', [
193                         RunScript(os.path.join("external", "vulkancts", "scripts", "build_mustpass.py"),
194                                           lambda env: ["--build-dir", os.path.join(env.tmpDir, "vulkan-mustpass")]),
195                 ]),
196         ('gen-inl-files', [
197                         RunScript(os.path.join("scripts", "gen_egl.py")),
198                         RunScript(os.path.join("scripts", "opengl", "gen_all.py")),
199                         RunScript(os.path.join("external", "vulkancts", "scripts", "gen_framework.py")),
200                         RunScript(os.path.join("scripts", "src_util", "check_all.py")),
201                 ])
202 ]
203
204 def getBuildRecipes ():
205         return [(b.getName(), [b]) for b in BUILD_TARGETS]
206
207 def getAllRecipe (recipes):
208         allSteps = []
209         for name, steps in recipes:
210                 allSteps += steps
211         return ("all", allSteps)
212
213 def getRecipes ():
214         recipes = getBuildRecipes()
215         recipes += SPECIAL_RECIPES
216         return recipes
217
218 def getRecipe (recipes, recipeName):
219         for curName, steps in recipes:
220                 if curName == recipeName:
221                         return (curName, steps)
222         return None
223
224 RECIPES                 = getRecipes()
225
226 def parseArgs ():
227         parser = argparse.ArgumentParser(description = "Build and test source",
228                                                                          formatter_class=argparse.ArgumentDefaultsHelpFormatter)
229         parser.add_argument("-s",
230                                                 "--src-dir",
231                                                 dest="srcDir",
232                                                 default=DEQP_DIR,
233                                                 help="Source directory")
234         parser.add_argument("-t",
235                                                 "--tmp-dir",
236                                                 dest="tmpDir",
237                                                 default=os.path.join(tempfile.gettempdir(), "deqp-build-test"),
238                                                 help="Temporary directory")
239         parser.add_argument("-r",
240                                                 "--recipe",
241                                                 dest="recipe",
242                                                 choices=[n for n, s in RECIPES] + ["all"],
243                                                 default="all",
244                                                 help="Build / test recipe")
245         parser.add_argument("-d",
246                                                 "--dump-recipes",
247                                                 dest="dumpRecipes",
248                                                 action="store_true",
249                                                 help="Print out recipes that have any available actions")
250         return parser.parse_args()
251
252 if __name__ == "__main__":
253         args    = parseArgs()
254         env             = Environment(args.srcDir, args.tmpDir)
255
256         if args.dumpRecipes:
257                 for name, steps in RECIPES:
258                         for step in steps:
259                                 if step.isAvailable(env):
260                                         print name
261                                         break
262         else:
263                 name, steps     = getAllRecipe(RECIPES) if args.recipe == "all" \
264                                           else getRecipe(RECIPES, args.recipe)
265
266                 print "Running %s" % name
267
268                 runRecipe(steps)
269
270                 print "All steps completed successfully"