python类timeit()的实例源码

def tearDown(self):
        if self.src_before and self.optimizations:
            if not isinstance(self.src_before, (list, tuple)):
                self.src_before = (self.src_before, )
            if not isinstance(self.optimizations, (list, tuple)):
                self.optimizations = (self.optimizations, )
            for src_before in self.src_before:
                src_after = src_before
                for optimization in self.optimizations:
                    src_after     = self.optimize(src_after, optimization)
                self.time_before += timeit(src_before, setup=self.set_up)
                self.time_after  += timeit(src_after , setup=self.set_up)
            self.assertGreaterEqual(self.time_before, self.time_after)
        self.time_before   = 0 
        self.time_after    = 0
        self.src_before    = ()
        self.optimizations = ()
        self.set_up        = None

def get_env(ctx):
    return dict(
        print=print_,
        timeit=timeit,
        dis=dis,
        discord=discord,
        bot=ctx.bot,
        client=ctx.bot,
        ctx=ctx,
        con=ctx.con,
        msg=ctx.message,
        message=ctx.message,
        guild=ctx.guild,
        server=ctx.guild,
        channel=ctx.channel,
        me=ctx.me
    )

def plot():
    '''

    '''

    # Register the functions
    builtins.__dict__.update(globals())

    # Loop over various dataset sizes
    Narr = np.logspace(0, 5, 5)
    tpp = np.zeros_like(Narr)
    tbm = np.zeros_like(Narr)
    tps = np.zeros_like(Narr)
    for i, N in enumerate(Narr):
        tpp[i] = timeit.timeit('run_pp(%d)' % N, number = 10) / 10.
        if batman is not None:
            tbm[i] = timeit.timeit('run_bm(%d)' % N, number = 10) / 10.
        if ps is not None:
            tps[i] = timeit.timeit('run_ps(%d)' % N, number = 10) / 10.

    pl.plot(Narr, tpp, '-o', label = 'planetplanet')
    if batman is not None:
        pl.plot(Narr, tbm, '-o', label = 'batman')
    if ps is not None:
        pl.plot(Narr, tps, '-o', label = 'pysyzygy')
    pl.legend()
    pl.yscale('log')
    pl.xscale('log')
    pl.ylabel('Time [seconds]', fontweight = 'bold')
    pl.xlabel('Number of datapoints', fontweight = 'bold')

def bench(func, iterations, stat_memory):
    gc.collect()
    heap_diff = None

    if heapy and stat_memory:
        heap_before = heapy.heap()

    total_sec = timeit.timeit(func, setup=gc.enable, number=iterations)

    if heapy and stat_memory:
        heap_diff = heapy.heap() - heap_before

    sec_per_req = Decimal(str(total_sec)) / Decimal(str(iterations))

    sys.stdout.write('.')
    sys.stdout.flush()

    return (sec_per_req, heap_diff)

def determine_iterations(func):
    # NOTE(kgriffs): Algorithm adapted from IPython's magic timeit
    # function to determine iterations so that 0.2 <= total time < 2.0
    iterations = ITER_DETECTION_MULTIPLIER
    for __ in range(1, ITER_DETECTION_MAX_ATTEMPTS):
        gc.collect()

        total_sec = timeit.timeit(
            func,
            setup=gc.enable,
            number=int(iterations)
        )

        if total_sec >= ITER_DETECTION_DURATION_MIN:
            assert total_sec < ITER_DETECTION_DURATION_MAX
            break

        iterations *= ITER_DETECTION_MULTIPLIER

    return int(iterations)

def timeit(self, stmt, setup, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_time = t.timeit(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, 1)
        self.assertEqual(self.fake_timer.count, number)
        self.assertEqual(delta_time, number)

    # Takes too long to run in debug build.
    #def test_timeit_default_iters(self):
    #    self.timeit(self.fake_stmt, self.fake_setup)

def repeat(self, stmt, setup, repeat=None, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if repeat is None:
            repeat = DEFAULT_REPEAT
        else:
            kwargs['repeat'] = repeat
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_times = t.repeat(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, repeat)
        self.assertEqual(self.fake_timer.count, repeat * number)
        self.assertEqual(delta_times, repeat * [float(number)])

    # Takes too long to run in debug build.
    #def test_repeat_default(self):
    #    self.repeat(self.fake_stmt, self.fake_setup)

def test_perf():

    print('[+] NAS MO decoding and re-encoding')
    Ta = timeit(test_nas_mo, number=14)
    print('test_nas_mo: {0:.4f}'.format(Ta))

    print('[+] NAS MT decoding and re-encoding')
    Tb = timeit(test_nas_mt, number=24)
    print('test_nas_mt: {0:.4f}'.format(Tb))

    print('[+] SIGTRAN decoding and re-encoding')
    Tc = timeit(test_sigtran, number=300)
    print('test_sigtran: {0:.4f}'.format(Tc))

    print('[+] SCCP decoding and re-encoding')
    Td = timeit(test_sccp, number=100)
    print('test_sccp: {0:.4f}'.format(Td))

    print('[+] mobile total time: {0:.4f}'.format(Ta+Tb+Tc+Td))

def timeit(self, stmt, setup, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_time = t.timeit(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, 1)
        self.assertEqual(self.fake_timer.count, number)
        self.assertEqual(delta_time, number)

    # Takes too long to run in debug build.
    #def test_timeit_default_iters(self):
    #    self.timeit(self.fake_stmt, self.fake_setup)

def repeat(self, stmt, setup, repeat=None, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if repeat is None:
            repeat = DEFAULT_REPEAT
        else:
            kwargs['repeat'] = repeat
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_times = t.repeat(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, repeat)
        self.assertEqual(self.fake_timer.count, repeat * number)
        self.assertEqual(delta_times, repeat * [float(number)])

    # Takes too long to run in debug build.
    #def test_repeat_default(self):
    #    self.repeat(self.fake_stmt, self.fake_setup)

def timeit(self, stmt, setup, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_time = t.timeit(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, 1)
        self.assertEqual(self.fake_timer.count, number)
        self.assertEqual(delta_time, number)

    # Takes too long to run in debug build.
    #def test_timeit_default_iters(self):
    #    self.timeit(self.fake_stmt, self.fake_setup)

def repeat(self, stmt, setup, repeat=None, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if repeat is None:
            repeat = DEFAULT_REPEAT
        else:
            kwargs['repeat'] = repeat
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_times = t.repeat(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, repeat)
        self.assertEqual(self.fake_timer.count, repeat * number)
        self.assertEqual(delta_times, repeat * [float(number)])

    # Takes too long to run in debug build.
    #def test_repeat_default(self):
    #    self.repeat(self.fake_stmt, self.fake_setup)

def run_timeit(func_1, func_2, num=1):
    """Run timeit.timeit for the given function names (input args)

    .. todo:: Make this function robust by handling errors due to incorrect
       function names.
    .. todo:: You could also refactor this function and pass the whole
     function as an argument. Then you can extract the function name string
     as function.__name__
    """

    t1 = timeit.timeit("%s()"%func_1,
                       setup="from __main__ import %s"%func_1, number=num)
    t2 = timeit.timeit("%s()"%func_2,
                       setup="from __main__ import %s"%func_2, number=num)

    print("Function: {func}, time: {t}".format(func=func_1, t=t1))
    print("Function: {func}, time: {t}".format(func=func_2, t=t2))
    print("~"*40)

def run_timeit(func_1, func_2, num=1):
    """Run timeit.timeit for the given function names (input args)

    .. todo:: Make this function robust by handling errors due to incorrect
       function names.
    .. todo:: You could also refactor this function and pass the whole
     function as an argument. Then you can extract the function name string
     as function.__name__
    """

    t1 = timeit.timeit("%s()"%func_1,
                       setup="from __main__ import %s"%func_1, number=num)
    t2 = timeit.timeit("%s()"%func_2,
                       setup="from __main__ import %s"%func_2, number=num)

    print("Function: {func}, time: {t}".format(func=func_1, t=t1))
    print("Function: {func}, time: {t}".format(func=func_2, t=t2))
    print("~"*40)

def timeit(self, stmt, setup, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_time = t.timeit(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, 1)
        self.assertEqual(self.fake_timer.count, number)
        self.assertEqual(delta_time, number)

    # Takes too long to run in debug build.
    #def test_timeit_default_iters(self):
    #    self.timeit(self.fake_stmt, self.fake_setup)

def repeat(self, stmt, setup, repeat=None, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if repeat is None:
            repeat = DEFAULT_REPEAT
        else:
            kwargs['repeat'] = repeat
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_times = t.repeat(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, repeat)
        self.assertEqual(self.fake_timer.count, repeat * number)
        self.assertEqual(delta_times, repeat * [float(number)])

    # Takes too long to run in debug build.
    #def test_repeat_default(self):
    #    self.repeat(self.fake_stmt, self.fake_setup)

def test_kmax_pooling_time():
  nbatches, nkernels_in, nwords, ndim = 50, 16, 58, 300
  input_shape = (nbatches, nkernels_in, nwords, ndim)

  input = T.tensor4('input')

  k = 1
  f_kmax_argsort = theano.function([input], k_max_pooling(input, k))
  f_kmax_unroll = theano.function([input], _k_max_pooling(input, k))
  f_max = theano.function([input], max_pooling(input))

  image_data = np.random.randn(*input_shape).astype(dtype=np.float64)
  # np.random.shuffle(image_data)
  image_data = image_data.reshape(input_shape)
  # print image_data
  # print 'kmax'
  print 'f_kmax_argsort', timeit.timeit(lambda: f_kmax_argsort(image_data), number=10)
  print 'f_kmax_unroll', timeit.timeit(lambda: f_kmax_unroll(image_data), number=10)
  print 'f_max', timeit.timeit(lambda: f_max(image_data), number=10)

def timeit(self, stmt, setup, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_time = t.timeit(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, 1)
        self.assertEqual(self.fake_timer.count, number)
        self.assertEqual(delta_time, number)

    # Takes too long to run in debug build.
    #def test_timeit_default_iters(self):
    #    self.timeit(self.fake_stmt, self.fake_setup)

def repeat(self, stmt, setup, repeat=None, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if repeat is None:
            repeat = DEFAULT_REPEAT
        else:
            kwargs['repeat'] = repeat
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_times = t.repeat(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, repeat)
        self.assertEqual(self.fake_timer.count, repeat * number)
        self.assertEqual(delta_times, repeat * [float(number)])

    # Takes too long to run in debug build.
    #def test_repeat_default(self):
    #    self.repeat(self.fake_stmt, self.fake_setup)

def test_kmax_pooling_time():
  nbatches, nkernels_in, nwords, ndim = 50, 16, 58, 300
  input_shape = (nbatches, nkernels_in, nwords, ndim)

  input = T.tensor4('input')

  k = 1
  f_kmax_argsort = theano.function([input], k_max_pooling(input, k))
  f_kmax_unroll = theano.function([input], _k_max_pooling(input, k))
  f_max = theano.function([input], max_pooling(input))

  image_data = np.random.randn(*input_shape).astype(dtype=np.float64)
  # np.random.shuffle(image_data)
  image_data = image_data.reshape(input_shape)
  # print image_data
  # print 'kmax'
  print 'f_kmax_argsort', timeit.timeit(lambda: f_kmax_argsort(image_data), number=10)
  print 'f_kmax_unroll', timeit.timeit(lambda: f_kmax_unroll(image_data), number=10)
  print 'f_max', timeit.timeit(lambda: f_max(image_data), number=10)

def test_performance_cache(self):
        """Compare the naive vanilla python lazy property
                (where property is written in C in the python stdlib)
            with our IRP lazy_property with the genealogy overhead

            Python 2.*: 1.25x Python 3.*: 1.75x
        """
        import timeit

        i = timeit.timeit('f.b0;', setup='from __main__ import BigTree; f = BigTree()', number=5000000)
        h = timeit.timeit('f.b0_vlp;', setup='from __main__ import BigTree; f = BigTree()', number=5000000)

        try:
            self.assertTrue(i < h*1.75)
        except AssertionError as e:
            raise e

def factorial():
    simple = timeit.timeit('fact_s(52)',
'''
from ch03_r07 import fact_s
''')

    optimized = timeit.timeit('fact_o(52)',
'''
from ch03_r07 import fact_o
''')

    while_statement = timeit.timeit('fact_w(52)',
'''
from ch03_r07 import fact_w
'''
    )

    print( "Simple    {simple:.4f}".format_map(vars()))
    print( "Optimized {optimized:.4f}".format_map(vars()))
    print( "While     {while_statement:.4f}".format_map(vars()))

def test_array_vs_getter(self):
    setup = '''data = ['a'] * 100\n'''
    setup += '''def get(n):\n'''
    setup += '''  return data[n]\n'''
    setup += '''class B:\n'''
    setup += '''  def __getitem__(self, n):\n'''
    setup += '''    return data[n]\n'''
    setup += '''b = B()\n'''
    a = timeit(
        '''x = data[5]\n''',
        setup=setup,
        number=10000)
    b = timeit(
        '''x = get(5)\n''',
        setup=setup,
        number=10000)
    c = timeit(
        '''x = b[5]\n''',
        setup=setup,
        number=10000)
    #print "\n%s %s %s | %s %s" % (a, b, a/b, c, a/c)
    # Calling a function or member is significantly slower than direct access.
    self.assertGreater(b, a * 1.7)
    self.assertGreater(c, a * 2)

def test_slice_vs_startswith(self):
    setup = '''x = 'a' * 100\n'''
    a = timeit(
        '''x[:2] == "  "\n''',
        setup=setup,
        number=100000)
    b = timeit(
        '''x.startswith("  ")\n''',
        setup=setup,
        number=100000)
    c = timeit(
        '''x[0] == " " and x[1] == " "\n''',
        setup=setup,
        number=100000)
    #print "\na %s, b %s, c %s | %s %s" % (a, b, c, c, a/c)
    # Calling a function or member is significantly slower than direct access.
    self.assertGreater(b, a * 2.0)  # b is much slower.
    self.assertGreater(b, c * 2.0)  # b is much slower.
    self.assertGreater(a, c * 0.7)  # a and c are similar.
    self.assertGreater(c, a * 0.7)  # a and c are similar.

def test_default_parameter(self):
    setup  = '''def withDefault(a, b=None):\n'''
    setup += '''  if b is not None: return b\n'''
    setup += '''  return a*a\n'''
    setup += '''def withoutDefault(a, b):\n'''
    setup += '''  if b is -1: return b\n'''
    setup += '''  return a*b\n'''
    a = timeit(
        '''withDefault(5);''' * 100,
        setup=setup,
        number=10000)
    b = timeit(
        '''withoutDefault(5, 0);''' * 100,
        setup=setup,
        number=10000)
    # Assert that neither too much faster than the other
    self.assertGreater(a, b * 0.81)
    self.assertGreater(b, a * 0.77)

def test_split_insert(self):
    return  # Remove to enable test (disabled due to running time).
    # This tests a performance assumption. If this test fails, the program
    # should still work fine, but it may not run as fast as it could by using
    # different assumptions.
    #
    # With frequent splitting the performance reverses.
    for lineCount in (100, 1000, 5000):
      half = lineCount / 2
      a = timeit(r'''data2 = data1.split('\n'); \
              data2[%s] = data2[%s][:50] + "x" + data2[%s][50:]; \
              ''' % (half, half, half),
          setup=r'''data1 = ("a" * 100 + '\n') * %s''' % (lineCount,),
          number=10000)
      b = timeit('data1 = data1[:%s] + "x" + data1[%s:]' % (half, half),
          setup=r'''data1 = ("a" * 100 + '\n') * %s''' % (lineCount,),
          number=10000)
      print "\n%9s: %s %s" % (lineCount, a, b)
      self.assertGreater(a, b)

def bench(func, iterations, stat_memory):
    gc.collect()
    heap_diff = None

    if heapy and stat_memory:
        heap_before = heapy.heap()

    total_sec = timeit.timeit(func, setup=gc.enable, number=iterations)

    if heapy and stat_memory:
        heap_diff = heapy.heap() - heap_before

    sec_per_req = Decimal(str(total_sec)) / Decimal(str(iterations))

    sys.stdout.write('.')
    sys.stdout.flush()

    return (sec_per_req, heap_diff)

def determine_iterations(func):
    # NOTE(kgriffs): Algorithm adapted from IPython's magic timeit
    # function to determine iterations so that 0.2 <= total time < 2.0
    iterations = ITER_DETECTION_MULTIPLIER
    for __ in range(1, ITER_DETECTION_MAX_ATTEMPTS):
        gc.collect()

        total_sec = timeit.timeit(
            func,
            setup=gc.enable,
            number=int(iterations)
        )

        if total_sec >= ITER_DETECTION_DURATION_MIN:
            assert total_sec < ITER_DETECTION_DURATION_MAX
            break

        iterations *= ITER_DETECTION_MULTIPLIER

    return int(iterations)

def permscan(self, address_space, offset = 0, maxlen = None):
    times = []
    # Run a warm-up scan to ensure the file is cached as much as possible
    self.oldscan(address_space, offset, maxlen)

    perms = list(itertools.permutations(self.checks))
    for i in range(len(perms)):
        self.checks = perms[i]
        print "Running scan {0}/{1}...".format(i + 1, len(perms))
        profobj = ScanProfInstance(self.oldscan, address_space, offset, maxlen)
        value = timeit.timeit(profobj, number = self.repeats)
        times.append((value, len(list(profobj.results)), i))

    print "Scan results"
    print "{0:20} | {1:7} | {2:6} | {3}".format("Time", "Results", "Perm #", "Ordering")
    for val, l, ordering in sorted(times):
        print "{0:20} | {1:7} | {2:6} | {3}".format(val, l, ordering, perms[ordering])
    sys.exit(1)

def timeit(self, stmt, setup, number=None):
        self.fake_timer = FakeTimer()
        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
        kwargs = {}
        if number is None:
            number = DEFAULT_NUMBER
        else:
            kwargs['number'] = number
        delta_time = t.timeit(**kwargs)
        self.assertEqual(self.fake_timer.setup_calls, 1)
        self.assertEqual(self.fake_timer.count, number)
        self.assertEqual(delta_time, number)

    # Takes too long to run in debug build.
    #def test_timeit_default_iters(self):
    #    self.timeit(self.fake_stmt, self.fake_setup)