buildtools/wafsamba/samba_optimisation.py

   1 # This file contains waf optimisations for Samba
   2
   3 # most of these optimisations are possible because of the restricted build environment
   4 # that Samba has. For example, Samba doesn't attempt to cope with Win32 paths during the
   5 # build, and Samba doesn't need build varients
   6
   7 # overall this makes some build tasks quite a bit faster
   8
   9 import os
  10 import Build, Utils, Node
  11 from TaskGen import feature, after, before
  12 import preproc, Task
  13
  14 @feature('cc', 'cxx')
  15 @after('apply_type_vars', 'apply_lib_vars', 'apply_core')
  16 def apply_incpaths(self):
  17     lst = []
  18
  19     try:
  20         kak = self.bld.kak
  21     except AttributeError:
  22         kak = self.bld.kak = {}
  23
  24     # TODO move the uselib processing out of here
  25     for lib in self.to_list(self.uselib):
  26         for path in self.env['CPPPATH_' + lib]:
  27             if not path in lst:
  28                 lst.append(path)
  29     if preproc.go_absolute:
  30         for path in preproc.standard_includes:
  31             if not path in lst:
  32                 lst.append(path)
  33
  34     for path in self.to_list(self.includes):
  35         if not path in lst:
  36             if preproc.go_absolute or path[0] != '/':  # os.path.isabs(path):
  37                 lst.append(path)
  38             else:
  39                 self.env.prepend_value('CPPPATH', path)
  40
  41     for path in lst:
  42         node = None
  43         if path[0] == '/': # os.path.isabs(path):
  44             if preproc.go_absolute:
  45                 node = self.bld.root.find_dir(path)
  46         elif path[0] == '#':
  47             node = self.bld.srcnode
  48             if len(path) > 1:
  49                 try:
  50                     node = kak[path]
  51                 except KeyError:
  52                     kak[path] = node = node.find_dir(path[1:])
  53         else:
  54             try:
  55                 node = kak[(self.path.id, path)]
  56             except KeyError:
  57                 kak[(self.path.id, path)] = node = self.path.find_dir(path)
  58
  59         if node:
  60             self.env.append_value('INC_PATHS', node)
  61
  62 @feature('cc')
  63 @after('apply_incpaths')
  64 def apply_obj_vars_cc(self):
  65     """after apply_incpaths for INC_PATHS"""
  66     env = self.env
  67     app = env.append_unique
  68     cpppath_st = env['CPPPATH_ST']
  69
  70     lss = env['_CCINCFLAGS']
  71
  72     try:
  73          cac = self.bld.cac
  74     except AttributeError:
  75          cac = self.bld.cac = {}
  76
  77     # local flags come first
  78     # set the user-defined includes paths
  79     for i in env['INC_PATHS']:
  80
  81         try:
  82             lss.extend(cac[i.id])
  83         except KeyError:
  84
  85             cac[i.id] = [cpppath_st % i.bldpath(env), cpppath_st % i.srcpath(env)]
  86             lss.extend(cac[i.id])
  87
  88     env['_CCINCFLAGS'] = lss
  89     # set the library include paths
  90     for i in env['CPPPATH']:
  91         app('_CCINCFLAGS', cpppath_st % i)
  92
  93 import Node, Environment
  94
  95 def vari(self):
  96     return "default"
  97 Environment.Environment.variant = vari
  98
  99 def variant(self, env):
 100     if not env: return 0
 101     elif self.id & 3 == Node.FILE: return 0
 102     else: return "default"
 103 Node.Node.variant = variant
 104
 105
 106 import TaskGen, Task
 107
 108 def create_task(self, name, src=None, tgt=None):
 109     task = Task.TaskBase.classes[name](self.env, generator=self)
 110     if src:
 111         task.set_inputs(src)
 112     if tgt:
 113         task.set_outputs(tgt)
 114     return task
 115 TaskGen.task_gen.create_task = create_task
 116
 117 def hash_constraints(self):
 118     a = self.attr
 119     sum = hash((str(a('before', '')),
 120             str(a('after', '')),
 121             str(a('ext_in', '')),
 122             str(a('ext_out', '')),
 123             self.__class__.maxjobs))
 124     return sum
 125 Task.TaskBase.hash_constraints = hash_constraints
 126
 127
 128 # import cc
 129 # from TaskGen import extension
 130 # import Utils
 131
 132 # @extension(cc.EXT_CC)
 133 # def c_hook(self, node):
 134 #     task = self.create_task('cc', node, node.change_ext('.o'))
 135 #     try:
 136 #         self.compiled_tasks.append(task)
 137 #     except AttributeError:
 138 #         raise Utils.WafError('Have you forgotten to set the feature "cc" on %s?' % str(self))
 139
 140 #     bld = self.bld
 141 #     try:
 142 #         dc = bld.dc
 143 #     except AttributeError:
 144 #         dc = bld.dc = {}
 145
 146 #     if task.outputs[0].id in dc:
 147 #         raise Utils.WafError('Samba, you are doing it wrong %r %s %s' % (task.outputs, task.generator, dc[task.outputs[0].id].generator))
 148 #     else:
 149 #         dc[task.outputs[0].id] = task
 150
 151 #     return task
 152
 153
 154 def suncc_wrap(cls):
 155     '''work around a problem with cc on solaris not handling module aliases
 156     which have empty libs'''
 157     if getattr(cls, 'solaris_wrap', False):
 158         return
 159     cls.solaris_wrap = True
 160     oldrun = cls.run
 161     def run(self):
 162         if self.env.CC_NAME == "sun" and not self.inputs:
 163             self.env = self.env.copy()
 164             self.env.append_value('LINKFLAGS', '-')
 165         return oldrun(self)
 166     cls.run = run
 167 suncc_wrap(Task.TaskBase.classes['cc_link'])
 168
 169
 170
 171 def hash_env_vars(self, env, vars_lst):
 172     idx = str(id(env)) + str(vars_lst)
 173     try:
 174         return self.cache_sig_vars[idx]
 175     except KeyError:
 176         pass
 177
 178     m = Utils.md5()
 179     m.update(''.join([str(env[a]) for a in vars_lst]))
 180
 181     ret = self.cache_sig_vars[idx] = m.digest()
 182     return ret
 183 Build.BuildContext.hash_env_vars = hash_env_vars
 184
 185
 186 def store_fast(self, filename):
 187     file = open(filename, 'wb')
 188     data = self.get_merged_dict()
 189     try:
 190         Build.cPickle.dump(data, file, -1)
 191     finally:
 192         file.close()
 193 Environment.Environment.store_fast = store_fast
 194
 195 def load_fast(self, filename):
 196     file = open(filename, 'rb')
 197     try:
 198         data = Build.cPickle.load(file)
 199     finally:
 200         file.close()
 201     self.table.update(data)
 202 Environment.Environment.load_fast = load_fast
 203
 204 def is_this_a_static_lib(self, name):
 205     try:
 206         cache = self.cache_is_this_a_static_lib
 207     except AttributeError:
 208         cache = self.cache_is_this_a_static_lib = {}
 209     try:
 210         return cache[name]
 211     except KeyError:
 212         ret = cache[name] = 'cstaticlib' in self.bld.name_to_obj(name, self.env).features
 213         return ret
 214 TaskGen.task_gen.is_this_a_static_lib = is_this_a_static_lib
 215
 216 def shared_ancestors(self):
 217     try:
 218         cache = self.cache_is_this_a_static_lib
 219     except AttributeError:
 220         cache = self.cache_is_this_a_static_lib = {}
 221     try:
 222         return cache[id(self)]
 223     except KeyError:
 224
 225         ret = []
 226         if 'cshlib' in self.features: # or 'cprogram' in self.features:
 227             if getattr(self, 'uselib_local', None):
 228                 lst = self.to_list(self.uselib_local)
 229                 ret = [x for x in lst if not self.is_this_a_static_lib(x)]
 230         cache[id(self)] = ret
 231         return ret
 232 TaskGen.task_gen.shared_ancestors = shared_ancestors
 233
 234 @feature('cc', 'cxx')
 235 @after('apply_link', 'init_cc', 'init_cxx', 'apply_core')
 236 def apply_lib_vars(self):
 237     """after apply_link because of 'link_task'
 238     after default_cc because of the attribute 'uselib'"""
 239
 240     # after 'apply_core' in case if 'cc' if there is no link
 241
 242     env = self.env
 243     app = env.append_value
 244     seen_libpaths = set([])
 245
 246     # OPTIMIZATION 1: skip uselib variables already added (700ms)
 247     seen_uselib = set([])
 248
 249     # 1. the case of the libs defined in the project (visit ancestors first)
 250     # the ancestors external libraries (uselib) will be prepended
 251     self.uselib = self.to_list(self.uselib)
 252     names = self.to_list(self.uselib_local)
 253
 254     seen = set([])
 255     tmp = Utils.deque(names) # consume a copy of the list of names
 256     while tmp:
 257         lib_name = tmp.popleft()
 258         # visit dependencies only once
 259         if lib_name in seen:
 260             continue
 261
 262         y = self.name_to_obj(lib_name)
 263         if not y:
 264             raise Utils.WafError('object %r was not found in uselib_local (required by %r)' % (lib_name, self.name))
 265         y.post()
 266         seen.add(lib_name)
 267
 268         # OPTIMIZATION 2: pre-compute ancestors shared libraries (100ms)
 269         tmp.extend(y.shared_ancestors())
 270
 271         # link task and flags
 272         if getattr(y, 'link_task', None):
 273
 274             link_name = y.target[y.target.rfind('/') + 1:]
 275             if 'cstaticlib' in y.features:
 276                 app('STATICLIB', link_name)
 277             elif 'cshlib' in y.features or 'cprogram' in y.features:
 278                 # WARNING some linkers can link against programs
 279                 app('LIB', link_name)
 280
 281             # the order
 282             self.link_task.set_run_after(y.link_task)
 283
 284             # for the recompilation
 285             dep_nodes = getattr(self.link_task, 'dep_nodes', [])
 286             self.link_task.dep_nodes = dep_nodes + y.link_task.outputs
 287
 288             # OPTIMIZATION 3: reduce the amount of function calls
 289             # add the link path too
 290             par = y.link_task.outputs[0].parent
 291             if id(par) not in seen_libpaths:
 292                 seen_libpaths.add(id(par))
 293                 tmp_path = par.bldpath(self.env)
 294                 if not tmp_path in env['LIBPATH']:
 295                     env.prepend_value('LIBPATH', tmp_path)
 296
 297
 298         # add ancestors uselib too - but only propagate those that have no staticlib
 299         for v in self.to_list(y.uselib):
 300             if v not in seen_uselib:
 301                 seen_uselib.add(v)
 302                 if not env['STATICLIB_' + v]:
 303                     if not v in self.uselib:
 304                         self.uselib.insert(0, v)
 305
 306     # 2. the case of the libs defined outside
 307     for x in self.uselib:
 308         for v in self.p_flag_vars:
 309             val = self.env[v + '_' + x]
 310             if val:
 311                 self.env.append_value(v, val)
 312
 313 @feature('cprogram', 'cshlib', 'cstaticlib')
 314 @after('apply_lib_vars')
 315 @before('apply_obj_vars')
 316 def samba_before_apply_obj_vars(self):
 317     """before apply_obj_vars for uselib, this removes the standard pathes"""
 318
 319     def is_standard_libpath(env, path):
 320         for _path in env.STANDARD_LIBPATH:
 321             if _path == os.path.normpath(path):
 322                 return True
 323         return False
 324
 325     v = self.env
 326
 327     for i in v['RPATH']:
 328         if is_standard_libpath(v, i):
 329             v['RPATH'].remove(i)
 330
 331     for i in v['LIBPATH']:
 332         if is_standard_libpath(v, i):
 333             v['LIBPATH'].remove(i)
 334
 335 @feature('cc')
 336 @before('apply_incpaths', 'apply_obj_vars_cc')
 337 def samba_stash_cppflags(self):
 338     """Fix broken waf ordering of CPPFLAGS"""
 339
 340     self.env.SAVED_CPPFLAGS = self.env.CPPFLAGS
 341     self.env.CPPFLAGS = []
 342
 343 @feature('cc')
 344 @after('apply_incpaths', 'apply_obj_vars_cc')
 345 def samba_pop_cppflags(self):
 346     """append stashed user CPPFLAGS after our internally computed flags"""
 347
 348     self.env.append_value('_CCINCFLAGS', self.env.SAVED_CPPFLAGS)
 349     self.env.SAVED_CPPFLAGS = []
 350
 351 @feature('cprogram', 'cshlib', 'cstaticlib')
 352 @before('apply_obj_vars', 'add_extra_flags')
 353 def samba_stash_linkflags(self):
 354     """stash away LINKFLAGS in order to fix waf's broken ordering wrt or
 355     user LDFLAGS"""
 356
 357     self.env.SAVE_LINKFLAGS = self.env.LINKFLAGS
 358     self.env.LINKFLAGS = []
 359
 360 @feature('cprogram', 'cshlib', 'cstaticlib')
 361 @after('apply_obj_vars', 'add_extra_flags')
 362 def samba_pop_linkflags(self):
 363     """after apply_obj_vars append saved LDFLAGS"""
 364
 365     self.env.append_value('LINKFLAGS', self.env.SAVE_LINKFLAGS)
 366     self.env.SAVE_LINKFLAGS = []