Changeset 0add2ea in rtems-source-builder


Ignore:
Timestamp:
Apr 3, 2013, 3:31:41 AM (7 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, 4.9, master
Children:
69e5938
Parents:
e4cb1d0
Message:

PR 2108, PR 2109. Add --jobs and --always-clean.

Refactor the options handling in defaults.py to allow the --jobs
option have varing specific parameters. The option supports 'none',
'max' and 'half' or a fraction to divide the number of CPUs or
an integer value which is the number of jobs. The --no-smp has
been removed.

The host specific modules have been changed to set the number of
CPUs in the defaults table.

Fixed the --keep-going to clean up is --always-clean is provided
even if the build has an error.

Location:
source-builder/sb
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • source-builder/sb/build.py

    re4cb1d0 r0add2ea  
    396396        if self.create_tar_files:
    397397            self.script.append('echo "==> %files:"')
    398             prefixbase = self.opts.prefixbase()
    399             if prefixbase is None:
    400                 prefixbase = ''
    401             inpath = path.join('%{buildroot}', prefixbase)
     398            inpath = path.abspath(self.config.expand('%{buildroot}'))
    402399            tardir = path.abspath(self.config.expand('%{_tardir}'))
    403400            self.script.append(self.config.expand('if test -d %s; then' % (inpath)))
     
    522519        if not check.host_setup(opts, _defaults):
    523520            if not opts.force():
    524                 raise error.general('host build environment is not set up' + 
     521                raise error.general('host build environment is not set up' +
    525522                                    ' correctly (use --force to proceed)')
    526523            _notice(opts, 'warning: forcing build with known host setup problems')
  • source-builder/sb/darwin.py

    re4cb1d0 r0add2ea  
    3434    exit_code, proc, output = e.shell(sysctl + 'hw.ncpu')
    3535    if exit_code == 0:
    36         smp_mflags = '-j' + output.split(' ')[1].strip()
     36        ncpus = output.split(' ')[1].strip()
    3737    else:
    38         smp_mflags = ''
     38        ncpus = '1'
    3939    defines = {
     40        '_ncpus':       ('none',    'none',     ncpus),
    4041        '_os':          ('none',    'none',     'darwin'),
    4142        '_host':        ('triplet', 'required', uname[4] + '-apple-darwin' + uname[2]),
     
    4950        '_prefix':      ('dir',     'optional', '%{_usr}'),
    5051        'optflags':     ('none',    'none',     '-O2'),
    51         '_smp_mflags':  ('none',    'none',     smp_mflags),
    5252        '__ldconfig':   ('exe',     'none',     ''),
    5353        '__xz':         ('exe',     'required', '%{_usr}/bin/xz'),
  • source-builder/sb/defaults.py

    re4cb1d0 r0add2ea  
    252252    """Process the command line in a common way for all Tool Builder commands."""
    253253
    254     #
    255     # The define and if it is a path and needs conversion.
    256     #
    257     _long_opts = { '--prefix'         : ('_prefix', True),
    258                    '--prefixbase'     : ('_prefixbase', True),
    259                    '--topdir'         : ('_topdir', True),
    260                    '--configdir'      : ('_configdir', True),
    261                    '--builddir'       : ('_builddir', True),
    262                    '--sourcedir'      : ('_sourcedir', True),
    263                    '--tmppath'        : ('_tmppath', True),
    264                    '--log'            : ('_logfile', False),
    265                    '--url'            : ('_url_base', False),
    266                    '--targetcflags'   : ('_targetcflags', False),
    267                    '--targetcxxflags' : ('_targetcxxflags', False),
    268                    '--libstdcxxflags' : ('_libstdcxxflags', False) }
    269 
    270     _long_true_opts = { '--force'    : '_force',
    271                         '--trace'    : '_trace',
    272                         '--dry-run'  : '_dry_run',
    273                         '--warn-all' : '_warn_all',
    274                         '--no-clean' : '_no_clean',
    275                         '--no-smp'   : '_no_smp',
    276                         '--rebuild'  : '_rebuild' }
    277 
    278     _target_triplets = { '--host'   : '_host',
    279                          '--build'  : '_build',
    280                          '--target' : '_target' }
     254    def __init__(self, argv, optargs):
     255        self._long_opts = {
     256            # key                 macro              handler            param  defs    init
     257            '--prefix'         : ('_prefix',         self._lo_path,     True,  None,  False),
     258            '--topdir'         : ('_topdir',         self._lo_path,     True,  None,  False),
     259            '--configdir'      : ('_configdir',      self._lo_path,     True,  None,  False),
     260            '--builddir'       : ('_builddir',       self._lo_path,     True,  None,  False),
     261            '--sourcedir'      : ('_sourcedir',      self._lo_path,     True,  None,  False),
     262            '--tmppath'        : ('_tmppath',        self._lo_path,     True,  None,  False),
     263            '--jobs'           : ('_jobs',           self._lo_jobs,     True,  'max', True),
     264            '--log'            : ('_logfile',        self._lo_string,   True,  None,  False),
     265            '--url'            : ('_url_base',       self._lo_string,   True,  None,  False),
     266            '--targetcflags'   : ('_targetcflags',   self._lo_string,   True,  None,  False),
     267            '--targetcxxflags' : ('_targetcxxflags', self._lo_string,   True,  None,  False),
     268            '--libstdcxxflags' : ('_libstdcxxflags', self._lo_string,   True,  None,  False),
     269            '--force'          : ('_force',          self._lo_bool,     False, '0',   True),
     270            '--quiet'          : ('_quiet',          self._lo_bool,     False, '0',   True),
     271            '--trace'          : ('_trace',          self._lo_bool,     False, '0',   True),
     272            '--dry-run'        : ('_dry_run',        self._lo_bool,     False, '0',   True),
     273            '--warn-all'       : ('_warn_all',       self._lo_bool,     False, '0',   True),
     274            '--no-clean'       : ('_no_clean',       self._lo_bool,     False, '0',   True),
     275            '--keep-going'     : ('_keep_going',     self._lo_bool,     False, '0',   True),
     276            '--always-clean'   : ('_always_clean',   self._lo_bool,     False, '0',   True),
     277            '--host'           : ('_host',           self._lo_triplets, True,  None,  False),
     278            '--build'          : ('_build',          self._lo_triplets, True,  None,  False),
     279            '--target'         : ('_target',         self._lo_triplets, True,  None,  False),
     280            '--help'           : (None,              self._lo_help,     False, None,  False)
     281            }
     282
     283        self.command_path = path.dirname(argv[0])
     284        if len(self.command_path) == 0:
     285            self.command_path = '.'
     286        self.command_name = path.basename(argv[0])
     287        self.argv = argv
     288        self.args = argv[1:]
     289        self.optargs = optargs
     290        self.defaults = {}
     291        self.defaults['_sbdir'] = ('dir', 'required', path.shell(self.command_path))
     292        self.opts = { 'params' : [] }
     293        for lo in self._long_opts:
     294            self.opts[lo[2:]] = self._long_opts[lo][3]
     295            if self._long_opts[lo][4]:
     296                self.defaults[self._long_opts[lo][0]] = ('none', 'none', self._long_opts[lo][3])
     297        self._process()
     298
     299    def __str__(self):
     300        def _dict(dd):
     301            s = ''
     302            ddl = dd.keys()
     303            ddl.sort()
     304            for d in ddl:
     305                s += '  ' + d + ': ' + str(dd[d]) + '\n'
     306            return s
     307
     308        s = 'command: ' + self.command() + \
     309            '\nargs: ' + str(self.args) + \
     310            '\nopts:\n' + _dict(self.opts)
     311
     312        return s
     313
     314    def _lo_string(self, opt, macro, value):
     315        if value is None:
     316            raise error.general('option requires a value: %s' % (opt))
     317        self.opts[opt[2:]] = value
     318        self.defaults[macro] = ('none', 'none', value)
     319
     320    def _lo_path(self, opt, macro, value):
     321        if value is None:
     322            raise error.general('option requires a path: %s' % (opt))
     323        value = path.shell(value)
     324        self.opts[opt[2:]] = value
     325        self.defaults[macro] = ('none', 'none', value)
     326
     327    def _lo_jobs(self, opt, macro, value):
     328        if value is None:
     329            raise error.general('option requires a value: %s' % (opt))
     330        ok = False
     331        if value in ['max', 'none', 'half']:
     332            ok = True
     333        else:
     334            try:
     335                i = int(value)
     336                ok = True
     337            except:
     338                pass
     339            if not ok:
     340                try:
     341                    f = float(value)
     342                    ok = True
     343                except:
     344                    pass
     345        if not ok:
     346            raise error.general('invalid jobs option: %s' % (value))
     347        self.defaults[macro] = ('none', 'none', value)
     348        self.opts[opt[2:]] = value
     349
     350    def _lo_bool(self, opt, macro, value):
     351        if value is not None:
     352            raise error.general('option does not take a value: %s' % (opt))
     353        self.opts[opt[2:]] = '1'
     354        self.defaults[macro] = ('none', 'none', '1')
     355
     356    def _lo_triplets(self, opt, macro, value):
     357        #
     358        # This is a target triplet. Run it past config.sub to make make sure it
     359        # is ok.  The target triplet is 'cpu-vendor-os'.
     360        #
     361        e = execute.capture_execution()
     362        config_sub = path.join(self.command_path,
     363                               basepath, 'config.sub')
     364        exit_code, proc, output = e.shell(config_sub + ' ' + value)
     365        if exit_code == 0:
     366            value = output
     367        self.defaults[macro] = ('triplet', 'none', value)
     368        self.opts[opt[2:]] = value
     369        _cpu = macro + '_cpu'
     370        _arch = macro + '_arch'
     371        _vendor = macro + '_vendor'
     372        _os = macro + '_os'
     373        _arch_value = ''
     374        _vendor_value = ''
     375        _os_value = ''
     376        dash = value.find('-')
     377        if dash >= 0:
     378            _arch_value = value[:dash]
     379            value = value[dash + 1:]
     380        dash = value.find('-')
     381        if dash >= 0:
     382            _vendor_value = value[:dash]
     383            value = value[dash + 1:]
     384        if len(value):
     385            _os_value = value
     386        self.defaults[_cpu] = ('none', 'none', _arch_value)
     387        self.defaults[_arch] = ('none', 'none', _arch_value)
     388        self.defaults[_vendor] = ('none', 'none', _vendor_value)
     389        self.defaults[_os] = ('none', 'none', _os_value)
     390
     391    def _lo_help(self, opt, macro, value):
     392        self.help()
    281393
    282394    def _help(self):
     
    285397        print 'Options and arguments:'
    286398        print '--force                : Force the build to proceed'
    287         print '--trace                : Trace the execution (not current used)'
     399        print '--quiet                : Quiet output (not used)'
     400        print '--trace                : Trace the execution'
    288401        print '--dry-run              : Do everything but actually run the build'
    289402        print '--warn-all             : Generate warnings'
    290403        print '--no-clean             : Do not clean up the build tree'
    291         print '--no-smp               : Run with 1 job and not as many as CPUs'
    292         print '--rebuild              : Rebuild (not used)'
     404        print '--always-clean         : Always clean the build tree, even with an error'
     405        print '--jobs                 : Run with specified number of jobs, default: num CPUs.'
    293406        print '--host                 : Set the host triplet'
    294407        print '--build                : Set the build triplet'
    295408        print '--target               : Set the target triplet'
    296409        print '--prefix path          : Tools build prefix, ie where they are installed'
    297         print '--prefixbase path      : '
    298410        print '--topdir path          : Top of the build tree, default is $PWD'
    299411        print '--configdir path       : Path to the configuration directory, default: ./config'
     
    313425        raise error.exit()
    314426
    315     def __init__(self, argv, optargs):
    316         self.command_path = path.dirname(argv[0])
    317         if len(self.command_path) == 0:
    318             self.command_path = '.'
    319         self.command_name = path.basename(argv[0])
    320         self.argv = argv
    321         self.args = argv[1:]
    322         self.optargs = optargs
    323         self.defaults = {}
    324         for to in command_line._long_true_opts:
    325             self.defaults[command_line._long_true_opts[to]] = ('none', 'none', '0')
    326         self.defaults['_sbdir'] = ('dir', 'required', path.shell(self.command_path))
    327         self.opts = { 'params'   : [],
    328                       'warn-all' : '0',
    329                       'quiet'    : '0',
    330                       'force'    : '0',
    331                       'trace'    : '0',
    332                       'dry-run'  : '0',
    333                       'no-clean' : '0',
    334                       'no-smp'   : '0',
    335                       'rebuild'  : '0' }
    336         self._process()
    337 
    338     def __str__(self):
    339         def _dict(dd):
    340             s = ''
    341             ddl = dd.keys()
    342             ddl.sort()
    343             for d in ddl:
    344                 s += '  ' + d + ': ' + str(dd[d]) + '\n'
    345             return s
    346 
    347         s = 'command: ' + self.command() + \
    348             '\nargs: ' + str(self.args) + \
    349             '\nopts:\n' + _dict(self.opts)
    350 
    351         return s
    352 
    353427    def _process(self):
    354 
    355         def _process_lopt(opt, arg, long_opts, args, values = False):
    356             for lo in long_opts:
    357                 if values and opt.startswith(lo):
    358                     equals = opt.find('=')
    359                     if equals < 0:
    360                         if arg == len(args) - 1:
    361                             raise error.general('missing option value: ' + lo)
    362                         arg += 1
    363                         value = args[arg]
     428        arg = 0
     429        while arg < len(self.args):
     430            a = self.args[arg]
     431            if a == '-?':
     432                self._help()
     433            elif a.startswith('--'):
     434                los = a.split('=')
     435                lo = los[0]
     436                if lo in self._long_opts:
     437                    long_opt = self._long_opts[lo]
     438                    if len(los) == 1:
     439                        if long_opt[2]:
     440                            if arg == len(args) - 1:
     441                                raise error.general('option requires a parameter: %s' % (lo))
     442                            arg += 1
     443                            value = args[arg]
     444                        else:
     445                            value = None
    364446                    else:
    365                         value = opt[equals + 1:]
    366                     if type(long_opts[lo]) is tuple:
    367                         if long_opts[lo][1]:
    368                             value = path.shell(value)
    369                         macro = long_opts[lo][0]
    370                     else:
    371                         macro = long_opts[lo]
    372                     return lo, macro, value, arg
    373                 elif opt == lo:
    374                     return lo, long_opts[lo], True, arg
    375             return None, None, None, arg
    376 
    377         i = 0
    378         while i < len(self.args):
    379             a = self.args[i]
    380             if a.startswith('-'):
    381                 if a.startswith('--'):
    382                     if a.startswith('--warn-all'):
    383                         self.opts['warn-all'] = True
    384                     elif a == '--help':
    385                         self._help()
    386                     else:
    387                         lo, macro, value, i = _process_lopt(a, i,
    388                                                             command_line._long_true_opts,
    389                                                             self.args)
    390                         if lo:
    391                             self.defaults[macro] = ('none', 'none', '1')
    392                             self.opts[lo[2:]] = '1'
    393                         else:
    394                             lo, macro, value, i = _process_lopt(a, i,
    395                                                                 command_line._long_opts,
    396                                                                 self.args, True)
    397                             if lo:
    398                                 self.defaults[macro] = ('none', 'none', value)
    399                                 self.opts[lo[2:]] = value
    400                             else:
    401                                 #
    402                                 # The target triplet is 'cpu-vendor-os'.
    403                                 #
    404                                 lo, macro, value, i = _process_lopt(a, i,
    405                                                                     command_line._target_triplets,
    406                                                                     self.args, True)
    407                                 if lo:
    408                                     #
    409                                     # This is a target triplet. Run it past config.sub to make
    410                                     # make sure it is ok.
    411                                     #
    412                                     e = execute.capture_execution()
    413                                     config_sub = path.join(self.command_path,
    414                                                            basepath, 'config.sub')
    415                                     exit_code, proc, output = e.shell(config_sub + ' ' + value)
    416                                     if exit_code == 0:
    417                                         value = output
    418                                     self.defaults[macro] = ('triplet', 'none', value)
    419                                     self.opts[lo[2:]] = value
    420                                     _arch = macro + '_cpu'
    421                                     _vendor = macro + '_vendor'
    422                                     _os = macro + '_os'
    423                                     _arch_value = ''
    424                                     _vendor_value = ''
    425                                     _os_value = ''
    426                                     dash = value.find('-')
    427                                     if dash >= 0:
    428                                         _arch_value = value[:dash]
    429                                         value = value[dash + 1:]
    430                                     dash = value.find('-')
    431                                     if dash >= 0:
    432                                         _vendor_value = value[:dash]
    433                                         value = value[dash + 1:]
    434                                     if len(value):
    435                                         _os_value = value
    436                                     self.defaults[_arch] = ('none', 'none', _arch_value)
    437                                     self.defaults[_vendor] = ('none', 'none', _vendor_value)
    438                                     self.defaults[_os] = ('none', 'none', _os_value)
    439                                 if not lo:
    440                                     sa = a.split('=')
    441                                     if sa[0] not in self.optargs:
    442                                         raise error.general('invalid argument (try --help): %s' % (a))
    443                 else:
    444                     if a == '-f':
    445                         self.opts['force'] = '1'
    446                     elif a == '-n':
    447                         self.opts['dry-run'] = '1'
    448                     elif a == '-q':
    449                         self.opts['quiet'] = '1'
    450                     elif a == '-?':
    451                         self._help()
    452                     else:
    453                         raise error.general('invalid argument (try --help): %s' % (a))
     447                        value = '='.join(los[1:])
     448                    long_opt[1](lo, long_opt[0], value)
    454449            else:
    455450                self.opts['params'].append(a)
    456             i += 1
     451            arg += 1
    457452
    458453    def _post_process(self, _defaults):
    459         if self.no_smp():
    460             _defaults['_smp_mflags'] = ('none', 'none', _defaults['nil'][2])
    461454        if _defaults['_host'][2] == _defaults['nil'][2]:
    462455            raise error.general('host not set')
     456        if '_ncpus' not in _defaults:
     457            raise error.general('host number of CPUs not set')
     458        ncpus = self.jobs(_defaults['_ncpus'][2])
     459        if ncpus > 1:
     460            _defaults['_smp_mflags'] = ('none', 'none', '-j %d' % (ncpus))
     461        else:
     462            _defaults['_smp_mflags'] = ('none', 'none', _defaults['nil'][2])
    463463        return _defaults
    464464
     
    507507        return self.opts['warn-all'] != '0'
    508508
     509    def keep_going(self):
     510        return self.opts['keep-going'] != '0'
     511
    509512    def no_clean(self):
    510513        return self.opts['no-clean'] != '0'
    511514
    512     def no_smp(self):
    513         return self.opts['no-smp'] != '0'
    514 
    515     def rebuild(self):
    516         return self.opts['rebuild'] != '0'
     515    def always_clean(self):
     516        return self.opts['always-clean'] != '0'
     517
     518    def jobs(self, cpus):
     519        cpus = int(cpus)
     520        if self.opts['jobs'] == 'none':
     521            cpus = 0
     522        elif self.opts['jobs'] == 'max':
     523            pass
     524        elif self.opts['jobs'] == 'half':
     525            cpus = cpus / 2
     526        else:
     527            ok = False
     528            try:
     529                i = int(self.opts['jobs'])
     530                cpus = i
     531                ok = True
     532            except:
     533                pass
     534            if not ok:
     535                try:
     536                    f = float(self.opts['jobs'])
     537                    cpus = f * cpus
     538                    ok = True
     539                except:
     540                    pass
     541                if not ok:
     542                    raise error.internal('bad jobs option: %s' % (self.opts['jobs']))
     543        if cpus <= 0:
     544            cpu = 1
     545        return cpus
    517546
    518547    def params(self):
     
    567596
    568597    def urls(self):
    569         if 'url' in self.opts:
     598        if self.opts['url'] is not None:
    570599            return self.opts['url'].split(',')
    571         return None
    572 
    573     def prefixbase(self):
    574         if 'prefixbase' in self.opts:
    575             return self.opts['prefixbase']
    576600        return None
    577601
  • source-builder/sb/freebsd.py

    re4cb1d0 r0add2ea  
    3636    exit_code, proc, output = e.shell(sysctl + 'hw.ncpu')
    3737    if exit_code == 0:
    38         smp_mflags = '-j' + output.split(' ')[1].strip()
     38        ncpus = output.split(' ')[1].strip()
    3939    else:
    40         smp_mflags = ''
     40        ncpus = '1'
    4141    if uname[4] == 'amd64':
    4242        cpu = 'x86_64'
     
    4747        version = version.split('-')[0]
    4848    defines = {
     49        '_ncpus':       ('none',    'none',     ncpus),
    4950        '_os':          ('none',    'none',     'freebsd'),
    5051        '_host':        ('triplet', 'required', cpu + '-freebsd' + version),
     
    5758        '_var':         ('dir',     'optional', '/usr/local/var'),
    5859        'optflags':     ('none',    'none',     '-O2 -I/usr/local/include -L/usr/local/lib'),
    59         '_smp_mflags':  ('none',    'none',     smp_mflags),
    6060        '__bash':       ('exe',     'optional', '/usr/local/bin/bash'),
    6161        '__bison':      ('exe',     'required', '/usr/local/bin/bison'),
  • source-builder/sb/linux.py

    re4cb1d0 r0add2ea  
    3636    e = execute.capture_execution()
    3737    exit_code, proc, output = e.shell(processors)
     38    ncpus = 0
    3839    if exit_code == 0:
    39         cpus = 0
    4040        try:
    4141            for l in output.split('\n'):
    4242                count = l.split(':')[1].strip()
    4343                if count > cpus:
    44                     cpus = int(count)
    45             if cpus > 0:
    46                 smp_mflags = '-j%d' % (cpus + 1)
     44                    ncpus = int(count)
    4745        except:
    4846            pass
     47    ncpus = str(ncpus + 1)
    4948    if uname[4].startswith('arm'):
    5049        cpu = 'arm'
     
    5352
    5453    defines = {
     54        '_ncpus':         ('none',    'none',     ncpus),
    5555        '_os':            ('none',    'none',     'linux'),
    5656        '_host':          ('triplet', 'required', cpu + '-linux-gnu'),
     
    6363        '_var':           ('dir',     'required', '/var'),
    6464        'optflags':       ('none',    'none',     '-O2 -pipe'),
    65         '_smp_mflags':    ('none',    'none',     smp_mflags),
    6665        '__bzip2':        ('exe',     'required', '/usr/bin/bzip2'),
    6766        '__gzip':         ('exe',     'required', '/bin/gzip'),
  • source-builder/sb/setbuilder.py

    re4cb1d0 r0add2ea  
    139139
    140140    def canadian_cross(self, _build):
    141         defaults_to_save = ['%{_prefix}', 
     141        defaults_to_save = ['%{_prefix}',
    142142                            '%{_tmproot}',
    143143                            '%{buildroot}',
     
    156156        for d in defaults_to_save:
    157157            _build.config.set_define(d, orig_defaults[d])
    158         self.root_copy(_build.config.expand('%{buildcxcroot}'), 
     158        self.root_copy(_build.config.expand('%{buildcxcroot}'),
    159159                       _build.config.expand('%{_tmpcxcroot}'))
    160160
     
    164164        _build.make()
    165165        self.report(_config, _build)
    166         self.root_copy(_build.config.expand('%{buildroot}'), 
     166        self.root_copy(_build.config.expand('%{buildroot}'),
    167167                       _build.config.expand('%{_tmproot}'))
    168168
     
    276276
    277277        current_path = os.environ['PATH']
    278        
     278
    279279        start = datetime.datetime.now()
    280280
     
    312312                        raise error.general('invalid config type: %s' % (configs[s]))
    313313                except error.general, gerr:
    314                     if self.opts.get_arg('--keep-going'):
     314                    if self.opts.keep_going():
    315315                        print gerr
     316                        if self.opts.always_clean():
     317                            builds += [b]
    316318                    else:
    317319                        raise
     
    319321                for b in builds:
    320322                    self.install(b.name(),
    321                                  b.config.expand('%{buildroot}'), 
     323                                 b.config.expand('%{buildroot}'),
    322324                                 b.config.expand('%{_prefix}'))
    323325            if deps is None and \
    324                     (not self.opts.no_clean() or self.opts.get_arg('--keep-going')):
     326                    (not self.opts.no_clean() or self.opts.always_clean()):
    325327                for b in builds:
    326328                    _notice(self.opts, 'cleaning: %s' % (b.name()))
     
    358360                    '--list-bsets':    'List available build sets',
    359361                    '--list-deps':     'List the dependent files.',
    360                     '--keep-going':    'Do not stop on error.',
    361362                    '--no-install':    'Do not install the packages to the prefix.',
    362363                    '--no-report':     'Do not create a package report.',
  • source-builder/sb/windows.py

    re4cb1d0 r0add2ea  
    5959
    6060    if os.environ.has_key('NUMBER_OF_PROCESSORS'):
    61         ncpus = int(os.environ['NUMBER_OF_PROCESSORS'])
     61        ncpus = os.environ['NUMBER_OF_PROCESSORS']
    6262    else:
    63         ncpus = 0
    64     if ncpus > 1:
    65         smp_mflags = '-j' + str(ncpus)
    66     else:
    67         smp_mflags = ''
     63        ncpus = '1'
    6864
    6965    defines = {
     66        '_ncpus':         ('none',    'none',     ncpus),
    7067        '_os':            ('none',    'none',     'win32'),
    7168        '_build':         ('triplet', 'required', build_triple),
Note: See TracChangeset for help on using the changeset viewer.