def __init__(self, m, six=False, net_if=None, num=5, packetsize=None, max_pool_size=None): super().__init__() self.m = check_m(m) self.__ping_cmd = 'ping6' if six else 'ping' self.__net_if = '-I %s' % (net_if) if net_if else '' if not num: num = 1 self.__num = '-c %d' % (num) if not packetsize: packetsize = '' if packetsize and packetsize > 1: packetsize = '-s %s' % (packetsize) self.__packetsize = packetsize if not max_pool_size: max_pool_size = _cpu_count() if max_pool_size < 1: max_pool_size = 1 self.__max_pool_size = max_pool_size self.__probe_results = dict() self.m( 'ping tool startup done', more=dict( pingc=self.__ping_cmd, net_if=self.__net_if, num=self.__num ), verbose=False )
def _mixprocess(data, key, iv, fn, to_string, threads=None): threads = threads if threads is not None else _cpu_count() assert len(key) == 16, "key must be 16 bytes long" assert len(iv) == 16, "iv must be 16 bytes long" assert threads >= 1, "you must use at least one thread" assert len(data) % _lib.MACRO_SIZE == 0, \ "plaintext size must be a multiple of %d" % _lib.MACRO_SIZE _data = ffi.from_buffer("unsigned char[]", data) _out = ffi.new("unsigned char[]", len(data)) _size = ffi.cast("unsigned long", len(data)) _thr = ffi.cast("unsigned int", threads) _key = ffi.new("unsigned char[]", key) _iv = ffi.new("unsigned char[]", iv) if fn in (_lib.mixencrypt, _lib.mixdecrypt): fn(_data, _out, _size, _key, _iv) elif fn in (_lib.t_mixencrypt, _lib.t_mixdecrypt): fn(_thr, _data, _out, _size, _key, _iv) elif fn in (_lib.mixslice, _lib.unsliceunmix): fn(_thr, _data, _out, _size, _key, _iv) else: raise Exception("unknown mix function %r" % fn) res = ffi.buffer(_out, len(data)) return res[:] if to_string else res
def system_load(pl, format='{avg:.1f}', threshold_good=1, threshold_bad=2, track_cpu_count=False, short=False): '''Return system load average. Highlights using ``system_load_good``, ``system_load_bad`` and ``system_load_ugly`` highlighting groups, depending on the thresholds passed to the function. :param str format: format string, receives ``avg`` as an argument :param float threshold_good: threshold for gradient level 0: any normalized load average below this value will have this gradient level. :param float threshold_bad: threshold for gradient level 100: any normalized load average above this value will have this gradient level. Load averages between ``threshold_good`` and ``threshold_bad`` receive gradient level that indicates relative position in this interval: (``100 * (cur-good) / (bad-good)``). Note: both parameters are checked against normalized load averages. :param bool track_cpu_count: if True powerline will continuously poll the system to detect changes in the number of CPUs. :param bool short: if True only the sys load over last 1 minute will be displayed. Divider highlight group used: ``background:divider``. Highlight groups used: ``system_load_gradient`` (gradient) or ``system_load``. ''' global cpu_count try: cpu_num = cpu_count = _cpu_count() if cpu_count is None or track_cpu_count else cpu_count except NotImplementedError: pl.warn('Unable to get CPU count: method is not implemented') return None ret = [] for avg in os.getloadavg(): normalized = avg / cpu_num if normalized < threshold_good: gradient_level = 0 elif normalized < threshold_bad: gradient_level = (normalized - threshold_good) * 100.0 / (threshold_bad - threshold_good) else: gradient_level = 100 ret.append({ 'contents': format.format(avg=avg), 'highlight_groups': ['system_load_gradient', 'system_load'], 'divider_highlight_group': 'background:divider', 'gradient_level': gradient_level, }) if short: return ret ret[0]['contents'] += ' ' ret[1]['contents'] += ' ' return ret
def system_load(pl, format='{avg:.1f}', threshold_good=1, threshold_bad=2, track_cpu_count=False): '''Return system load average. Highlights using ``system_load_good``, ``system_load_bad`` and ``system_load_ugly`` highlighting groups, depending on the thresholds passed to the function. :param str format: format string, receives ``avg`` as an argument :param float threshold_good: threshold for gradient level 0: any normalized load average below this value will have this gradient level. :param float threshold_bad: threshold for gradient level 100: any normalized load average above this value will have this gradient level. Load averages between ``threshold_good`` and ``threshold_bad`` receive gradient level that indicates relative position in this interval: (``100 * (cur-good) / (bad-good)``). Note: both parameters are checked against normalized load averages. :param bool track_cpu_count: if True powerline will continuously poll the system to detect changes in the number of CPUs. Divider highlight group used: ``background:divider``. Highlight groups used: ``system_load_gradient`` (gradient) or ``system_load``. ''' global cpu_count try: cpu_num = cpu_count = _cpu_count( ) if cpu_count is None or track_cpu_count else cpu_count except NotImplementedError: pl.warn('Unable to get CPU count: method is not implemented') return None ret = [] for avg in os.getloadavg(): normalized = avg / cpu_num if normalized < threshold_good: gradient_level = 0 elif normalized < threshold_bad: gradient_level = (normalized - threshold_good) * 100.0 / ( threshold_bad - threshold_good) else: gradient_level = 100 ret.append({ 'contents': format.format(avg=avg), 'highlight_group': ['system_load_gradient', 'system_load'], 'divider_highlight_group': 'background:divider', 'gradient_level': gradient_level, }) ret[0]['contents'] += ' ' ret[1]['contents'] += ' ' return ret
def __prepareParallel(self, parallel): maxParallelprocesses = _cpu_count() if parallel is None or parallel == 'max': parallel = maxParallelprocesses else: parallel = int(parallel) if parallel < 0: parallel = maxParallelprocesses + parallel self.__parallel = parallel self.info("Will use %d workers" % (self.__parallel))
def system_load(pl, format="{avg:.1f}", threshold_good=1, threshold_bad=2, track_cpu_count=False): """Return system load average. Highlights using ``system_load_good``, ``system_load_bad`` and ``system_load_ugly`` highlighting groups, depending on the thresholds passed to the function. :param str format: format string, receives ``avg`` as an argument :param float threshold_good: threshold for gradient level 0: any normalized load average below this value will have this gradient level. :param float threshold_bad: threshold for gradient level 100: any normalized load average above this value will have this gradient level. Load averages between ``threshold_good`` and ``threshold_bad`` receive gradient level that indicates relative position in this interval: (``100 * (cur-good) / (bad-good)``). Note: both parameters are checked against normalized load averages. :param bool track_cpu_count: if True powerline will continuously poll the system to detect changes in the number of CPUs. Divider highlight group used: ``background:divider``. Highlight groups used: ``system_load_gradient`` (gradient) or ``system_load``. """ global cpu_count try: cpu_num = cpu_count = _cpu_count() if cpu_count is None or track_cpu_count else cpu_count except NotImplementedError: pl.warn("Unable to get CPU count: method is not implemented") return None ret = [] for avg in os.getloadavg(): normalized = avg / cpu_num if normalized < threshold_good: gradient_level = 0 elif normalized < threshold_bad: gradient_level = (normalized - threshold_good) * 100.0 / (threshold_bad - threshold_good) else: gradient_level = 100 ret.append( { "contents": format.format(avg=avg), "highlight_group": ["system_load_gradient", "system_load"], "divider_highlight_group": "background:divider", "gradient_level": gradient_level, } ) ret[0]["contents"] += " " ret[1]["contents"] += " " return ret
def __init__(self, m, six=False, net_if=None, num=5, packetsize=None, max_pool_size=None): super().__init__() self.m = check_m(m) self.__ping_cmd = 'ping6' if six else 'ping' self.__net_if = '-I %s' % (net_if) if net_if else '' if not num: num = 1 self.__num = '-c %d' % (num) if not packetsize: packetsize = '' if packetsize and packetsize > 1: packetsize = '-s %s' % (packetsize) self.__packetsize = packetsize if not max_pool_size: max_pool_size = _cpu_count() if max_pool_size < 1: max_pool_size = 1 self.__max_pool_size = max_pool_size self.__probe_results = dict() self.m('ping tool startup done', more=dict(pingc=self.__ping_cmd, net_if=self.__net_if, num=self.__num), verbose=False)
# Copyright 2018 Robert Haas # For license information, see LICENSE.TXT in the package root directory from multiprocessing import cpu_count as _cpu_count _DETECTED_NUM_CORES = _cpu_count() def dask(function, argument_list, num_cores=None): """Apply a multivariate function to a list of arguments in a parallel fashion. Uses Dask's delayed() function to build a task graph and compute() function to calculate results. Args: function: A callable object that accepts more than one argument argument_list: An iterable object of input argument collections num_cores (optional): Number of cores to use for calculation. Returns: List of output results Example: >>> def add(x, y, z): ... return x+y+z ... >>> dask(add, [(1, 2, 3), (10, 20, 30)]) [6, 60] References: - https://dask.pydata.org
def _get_num_workers(num_workers): if num_workers == -1: return _cpu_count() - 1 return num_workers
def __init__(self, cpu_count=_cpu_count() - 1, buffer_size=10000): self.input_queue = Queue(buffer_size) self.output_queue = Queue() self.cpu_count = cpu_count
# TODO improve design global data data = tuple(seq_iter) # creates min(len(data), cpu_count) processes processes = [ Process(target=reverse_and_print_task, args=(q, c, v)) for _ in range(min(len(data), cpu_count)) ] for p in processes: p.start() for i in range(len(data)): q.put(i) # mark entries in queue for p in processes: q.put(None) for p in processes: p.join() if __name__ == '__main__': # generates each sequence seq_iter = read_sequences(stdin) cpu_count = _cpu_count() if cpu_count == 1: main_mono_prc(seq_iter) else: # TODO function can fail silently; fix main_multi_prc(seq_iter, cpu_count)