def test_profile_single_context(self):
        
        def id_callback():
            return self.callback_count
        def a():
            pass

        self.callback_count = 1
        yappi.set_context_id_callback(id_callback)
        yappi.start(profile_threads=False)
        a() # context-id:1
        self.callback_count = 2
        a() # context-id:2
        stats = yappi.get_func_stats()
        fsa = utils.find_stat_by_name(stats, "a")
        self.assertEqual(fsa.ncall, 1)
        yappi.stop()
        yappi.clear_stats()
        
        self.callback_count = 1
        yappi.start() # profile_threads=True
        a() # context-id:1
        self.callback_count = 2
        a() # context-id:2
        stats = yappi.get_func_stats()
        fsa = utils.find_stat_by_name(stats, "a")
        self.assertEqual(fsa.ncall, 2)

 def test_merge_multithreaded_stats(self):
     import threading
     import _yappi
     timings = {"a_1":2, "b_1":1}
     _yappi._set_test_timings(timings)
     def a(): pass
     def b(): pass
     yappi.start()
     t = threading.Thread(target=a)
     t.start()
     t.join()
     t = threading.Thread(target=b)
     t.start()
     t.join()
     yappi.get_func_stats().save("ystats1.ys")
     yappi.clear_stats()
     _yappi._set_test_timings(timings)
     self.assertEqual(len(yappi.get_func_stats()), 0)
     self.assertEqual(len(yappi.get_thread_stats()), 1)
     t = threading.Thread(target=a)
     t.start()
     t.join()
     
     self.assertEqual(_yappi._get_start_flags()["profile_builtins"], 0)
     self.assertEqual(_yappi._get_start_flags()["profile_multithread"], 1)
     yappi.get_func_stats().save("ystats2.ys")
    
     stats = yappi.YFuncStats(["ystats1.ys", "ystats2.ys",])
     fsa = utils.find_stat_by_name(stats, "a")
     fsb = utils.find_stat_by_name(stats, "b")
     self.assertEqual(fsa.ncall, 2)
     self.assertEqual(fsb.ncall, 1)
     self.assertEqual(fsa.tsub, fsa.ttot, 4)
     self.assertEqual(fsb.tsub, fsb.ttot, 1)

 def test_merge_load_different_clock_types(self):
     import threading
     yappi.start(builtins=True)
     def a(): b()
     def b(): c()
     def c(): pass
     t = threading.Thread(target=a)
     t.start()
     t.join()
     yappi.get_func_stats().sort("name", "asc").save("ystats1.ys")
     yappi.stop()
     yappi.clear_stats()
     yappi.start(builtins=False)
     t = threading.Thread(target=a)
     t.start()
     t.join()
     yappi.get_func_stats().save("ystats2.ys")
     yappi.stop()
     self.assertRaises(_yappi.error, yappi.set_clock_type, "wall")
     yappi.clear_stats()
     yappi.set_clock_type("wall")
     yappi.start()
     t = threading.Thread(target=a)
     t.start()
     t.join()
     yappi.get_func_stats().save("ystats3.ys")
     self.assertRaises(yappi.YappiError, yappi.YFuncStats().add("ystats1.ys").add, "ystats3.ys")
     stats = yappi.YFuncStats(["ystats1.ys", "ystats2.ys"]).sort("name")
     fsa = utils.find_stat_by_name(stats, "a")
     fsb = utils.find_stat_by_name(stats, "b")
     fsc = utils.find_stat_by_name(stats, "c")
     self.assertEqual(fsa.ncall, 2)
     self.assertEqual(fsa.ncall, fsb.ncall, fsc.ncall)

 def setUp(self):
     # reset everything back to default
     yappi.stop()
     yappi.clear_stats()
     yappi.set_clock_type('cpu') # reset to default clock type
     yappi.set_context_id_callback(None)
     yappi.set_context_name_callback(None)

    def stop_profiler(self):
        """
        Stop yappi and write the stats to the output directory.
        Return the path of the yappi statistics file.
        """
        if not self.profiler_running:
            raise RuntimeError("Profiler is not running")

        if not HAS_YAPPI:
            raise RuntimeError("Yappi cannot be found. Plase install the yappi library using your preferred package "
                               "manager and restart Tribler afterwards.")

        yappi.stop()

        yappi_stats = yappi.get_func_stats()
        yappi_stats.sort("tsub")

        log_dir = os.path.join(self.session.config.get_state_dir(), 'logs')
        file_path = os.path.join(log_dir, 'yappi_%s.stats' % self.profiler_start_time)
        # Make the log directory if it does not exist
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)

        yappi_stats.save(file_path, type='callgrind')
        yappi.clear_stats()
        self.profiler_running = False
        return file_path

def _stop_profiling(filename, format):
    logging.debug("Stopping CPU profiling")
    with _lock:
        if yappi.is_running():
            yappi.stop()
            stats = yappi.get_func_stats()
            stats.save(filename, format)
            yappi.clear_stats()

    def stop(self):
        if not yappi.is_running():
            raise UsageError("CPU profiler is not running")

        logging.info("Stopping CPU profiling")
        yappi.stop()
        stats = yappi.get_func_stats()
        stats.save(self.filename, self.format)
        yappi.clear_stats()

 def test_clear_stats_while_running(self):
     def a():            
         pass
     yappi.start()
     a()
     yappi.clear_stats()
     a()
     stats = yappi.get_func_stats()
     fsa = utils.find_stat_by_name(stats, 'a')
     self.assertEqual(fsa.ncall, 1)

 def do_action(self):
     action = self.cleaned_data['action']
     if action == 'start':
         yappi.start()
     elif action == 'start_with_builtins':
         yappi.start(builtins=True)
     elif action == 'stop':
         yappi.stop()
     elif action == 'reset':
         yappi.clear_stats()
     return action

    def _stop_profiling(self):
        with lock:
            if not yappi.is_running():
                raise http.Error(http.BAD_REQUEST, "profile is not running")

            log.info("Stopping profiling, writing profile to %r",
                     self.config.profile.filename)
            yappi.stop()
            stats = yappi.get_func_stats()
            stats.save(self.config.profile.filename, type="pstat")
            yappi.clear_stats()

 def test_subsequent_profile(self):
     import threading
     WORKER_COUNT = 5
     def a(): pass
     def b(): pass
     def c(): pass
     
     _timings = {"a_1":3,"b_1":2,"c_1":1,}
     
     yappi.start()
     def g(): pass
     g()
     yappi.stop()
     yappi.clear_stats()
     _yappi._set_test_timings(_timings)
     yappi.start()
     
     _dummy = []
     for i in range(WORKER_COUNT):
         t = threading.Thread(target=a)
         t.start()
         t.join()
     for i in range(WORKER_COUNT):
         t = threading.Thread(target=b)
         t.start()
         _dummy.append(t)
         t.join()
     for i in range(WORKER_COUNT):
         t = threading.Thread(target=a)
         t.start()
         t.join()
     for i in range(WORKER_COUNT):
         t = threading.Thread(target=c)
         t.start()
         t.join()    
     yappi.stop()    
     yappi.start()
     def f():
         pass
     f() 
     stats = yappi.get_func_stats()
     fsa = utils.find_stat_by_name(stats, 'a')
     fsb = utils.find_stat_by_name(stats, 'b')
     fsc = utils.find_stat_by_name(stats, 'c')
     self.assertEqual(fsa.ncall, 10)
     self.assertEqual(fsb.ncall, 5)
     self.assertEqual(fsc.ncall, 5)
     self.assertEqual(fsa.ttot, fsa.tsub, 30)
     self.assertEqual(fsb.ttot, fsb.tsub, 10)
     self.assertEqual(fsc.ttot, fsc.tsub, 5)
     
     # MACOSx optimizes by only creating one worker thread
     self.assertTrue(len(yappi.get_thread_stats()) >= 2) 

def profile_cpu_bound_program():
    real_dog = DogStatsApi()
    real_dog.reporter = NullReporter()
    fake_dog = NullDogStatsApi()
    for type_, dog in [('real', real_dog), ('fake', fake_dog)]:
        print('\n\n\nTESTING %s\n\n' % type_)
        dog.start()
        program = CPUBoundProgram(dog)
        yappi.start()
        program.run()
        yappi.print_stats(sort_type=yappi.SORTTYPE_TSUB, sort_order=yappi.SORTORDER_DESC)
        yappi.stop()
        yappi.clear_stats()

 def test_no_stats_different_clock_type_load(self):
     def a(): pass
     yappi.start()
     a()
     yappi.stop()
     yappi.get_func_stats().save("ystats1.ys")
     yappi.clear_stats()
     yappi.set_clock_type("WALL")
     yappi.start()
     yappi.stop()
     stats = yappi.get_func_stats().add("ystats1.ys")
     fsa = utils.find_stat_by_name(stats, 'a')
     self.assertTrue(fsa is not None)

    def test_run(self):

        def profiled():
            pass

        yappi.clear_stats()
        try:
            with yappi.run():
                profiled()
            stats = yappi.get_func_stats()
        finally:
            yappi.clear_stats()

        self.assertIsNotNone(utils.find_stat_by_name(stats, 'profiled'))

def profile_yappi(label):
    import yappi

    timestamp = datetime.now()
    yappi.start()
    _start = time.time()

    try:
        yield
    finally:
        _elapsed = time.time() - _start
        func_stats = yappi.get_func_stats()
        file_prefix = '/tmp/profile-yappi-%s-%s' % (label, timestamp.isoformat('T'))
        with open(file_prefix + '-summary.txt', 'w') as f:
            func_stats.print_all(out=f, columns={0:("name",140), 1:("ncall", 8), 2:("tsub", 8), 3:("ttot", 8), 4:("tavg",8)})
        func_stats.save(file_prefix + '.kgrind', 'CALLGRIND')
        yappi.stop()
        yappi.clear_stats()
        profiling_results.append((label, _elapsed))

def _handle_sigusr2(sig, stack):
    '''
    Signal handler for SIGUSR2, only available on Unix-like systems
    '''
    try:
        import yappi
    except ImportError:
        return
    if yappi.is_running():
        yappi.stop()
        filename = 'callgrind.salt-{0}-{1}'.format(int(time.time()), os.getpid())
        destfile = os.path.join(tempfile.gettempdir(), filename)
        yappi.get_func_stats().save(destfile, type='CALLGRIND')
        if sys.stderr.isatty():
            sys.stderr.write('Saved profiling data to: {0}\n'.format(destfile))
        yappi.clear_stats()
    else:
        if sys.stderr.isatty():
            sys.stderr.write('Profiling started\n')
        yappi.start()

    def test_run_recursive(self):

        def profiled():
            pass

        def not_profiled():
            pass

        yappi.clear_stats()
        try:
            with yappi.run():
                with yappi.run():
                    profiled()
                # Profiling stopped here
                not_profiled()
            stats = yappi.get_func_stats()
        finally:
            yappi.clear_stats()

        self.assertIsNotNone(utils.find_stat_by_name(stats, 'profiled'))
        self.assertIsNone(utils.find_stat_by_name(stats, 'not_profiled'))

    def test_builtin_profiling(self):
        def a():
            time.sleep(0.4) # is a builtin function
        yappi.set_clock_type('wall')

        yappi.start(builtins=True)
        a()
        stats = yappi.get_func_stats()
        fsa = utils.find_stat_by_name(stats, 'sleep')
        self.assertTrue(fsa is not None)
        self.assertTrue(fsa.ttot > 0.3)
        yappi.stop()
        yappi.clear_stats()
        
        def a():
            pass
        yappi.start()
        t = threading.Thread(target=a)
        t.start()
        t.join()
        stats = yappi.get_func_stats()

 def test_module_stress(self):
     self.assertEqual(yappi.is_running(), False)
     
     yappi.start()
     yappi.clear_stats()
     self.assertRaises(_yappi.error, yappi.set_clock_type, "wall")
     
     yappi.stop()
     yappi.clear_stats()
     yappi.set_clock_type("cpu")
     self.assertRaises(yappi.YappiError, yappi.set_clock_type, "dummy")
     self.assertEqual(yappi.is_running(), False)
     yappi.clear_stats()
     yappi.clear_stats()

 def test_pstats_conversion(self):
     def pstat_id(fs):
         return (fs.module, fs.lineno, fs.name)
     
     def a():
         d()
     def b():
         d()
     def c():
         pass
     def d():
         pass
         
     _timings = {"a_1":12,"b_1":7,"c_1":5,"d_1":2}
     _yappi._set_test_timings(_timings)            
     stats = utils.run_and_get_func_stats(a,)
     stats.strip_dirs()    
     stats.save("a1.pstats", type="pstat")
     fsa_pid = pstat_id(utils.find_stat_by_name(stats, "a"))
     fsd_pid = pstat_id(utils.find_stat_by_name(stats, "d"))
     yappi.clear_stats()
     _yappi._set_test_timings(_timings)
     stats = utils.run_and_get_func_stats(a,)
     stats.strip_dirs()
     stats.save("a2.pstats", type="pstat")
     yappi.clear_stats()
     _yappi._set_test_timings(_timings)
     stats = utils.run_and_get_func_stats(b,)        
     stats.strip_dirs()
     stats.save("b1.pstats", type="pstat")
     fsb_pid = pstat_id(utils.find_stat_by_name(stats, "b"))
     yappi.clear_stats()
     _yappi._set_test_timings(_timings)
     stats = utils.run_and_get_func_stats(c,)
     stats.strip_dirs()
     stats.save("c1.pstats", type="pstat")
     fsc_pid = pstat_id(utils.find_stat_by_name(stats, "c"))
     
     # merge saved stats and check pstats values are correct
     import pstats
     p = pstats.Stats('a1.pstats', 'a2.pstats', 'b1.pstats', 'c1.pstats')
     p.strip_dirs()
     # ct = ttot, tt = tsub
     (cc, nc, tt, ct, callers) = p.stats[fsa_pid]
     self.assertEqual(cc, nc, 2)
     self.assertEqual(tt, 20)
     self.assertEqual(ct, 24)
     (cc, nc, tt, ct, callers) = p.stats[fsd_pid]
     self.assertEqual(cc, nc, 3)
     self.assertEqual(tt, 6)
     self.assertEqual(ct, 6)        
     self.assertEqual(len(callers), 2)
     (cc, nc, tt, ct) = callers[fsa_pid]
     self.assertEqual(cc, nc, 2)
     self.assertEqual(tt, 4)
     self.assertEqual(ct, 4)
     (cc, nc, tt, ct) = callers[fsb_pid]
     self.assertEqual(cc, nc, 1)
     self.assertEqual(tt, 2)
     self.assertEqual(ct, 2)