Python yappi.get_thread_stats函数代码示例

    def cmd_stop(self, args):
        """stop profiling"""
        print "Profile results:"
        import yappi  # We do the import here so that we won't barf if run normally and yappi not available

        yappi.get_func_stats().print_all(
            columns={0: ("name", 50), 1: ("ncall", 5), 2: ("tsub", 8), 3: ("ttot", 8), 4: ("tavg", 8)}
        )
        yappi.get_thread_stats().print_all()
        yappi.stop()

def yappi_prof_call(func, *args):
    '''
        https://code.google.com/p/yappi/wiki/usageyappi_v092
    '''
    import yappi
    yappi.start()
    result = func(*args)
    yappi.get_func_stats().print_all()
    yappi.get_thread_stats().print_all()
    return result

def main():
    print('Main TID: {}'.format(gettid()))
    args = Bunch(channel=None,
                 devices=[],
                 generate=False,
                 ui='main.ui')
    yappi.start()
    exit_value = epyqlib.__main__.main(args=args)
    yappi.stop()
    yappi.get_func_stats().save('yappi.stats', type='pstat')
    yappi.get_thread_stats().print_all()
    return exit_value

def main(argv):
    parser = argparse.ArgumentParser(description='Convert a FASTA and QUAL pair of files into a FASQ file')
    parser.add_argument('fasta_filename',
                        help='the FASTA format input file path')
    parser.add_argument('qual_filename',
                        help='the QUAL format input file path')
    parser.add_argument('-q', action='store_true',
                        help="run quietly")
    parser.add_argument('-d', action='store_true',
                        help="print diagnostics to stderr")
    parser.add_argument('-z','--gzip', action='store_true',
                       help='input & output are gzipped')
    parser.add_argument('-p', '--profile', action='store_true',
                        help="profile this execution")
    parser.add_argument('-o', '--output',
                        default=sys.stdout, type=argparse.FileType('w'),
                        help='the output FASTQ file path')
    args = parser.parse_args()

    global debug_flag
    debug_flag = args.d

    debug_flag and sys.stderr.write("%r\n" % args)

    if args.profile:
        import yappi # https://code.google.com/p/yappi/wiki/apiyappi
        yappi.start(builtins=True)

    if args.gzip:
        import gzip
        fasta = gzip.open(args.fasta_filename)
        qual = gzip.open(args.qual_filename)
        outf = gzip.GzipFile(fileobj=args.output, mode='wb')
    else:
        fasta = open(args.fasta_filename)
        qual = open(args.qual_filename)
        outf = args.output

    # alphabet irrelevant (and makes it slow) records = PairedFastaQualIterator(fasta, qual, alphabet=IUPAC.ambiguous_dna)
    records = PairedFastaQualIterator(fasta, qual)
    count = SeqIO.write(records, outf, "fastq")
    outf.close()

    if args.profile:
        yappi.get_thread_stats().print_all(sys.stderr)
        yappi.get_func_stats().sort("subtime").print_all(sys.stderr)

    print("Converted %i records" % count)

    def test_print_formatting(self):
        def a():
            pass

        def b():
            a()

        func_cols = {1: ("name", 48), 0: ("ncall", 5), 2: ("tsub", 8)}
        thread_cols = {1: ("name", 48), 0: ("ttot", 8)}

        yappi.start()
        a()
        b()
        yappi.stop()
        fs = yappi.get_func_stats()
        cs = fs[1].children
        ts = yappi.get_thread_stats()
        # fs.print_all(out=sys.stderr, columns={1:("name", 70), })
        # cs.print_all(out=sys.stderr, columns=func_cols)
        # ts.print_all(out=sys.stderr, columns=thread_cols)
        # cs.print_all(out=sys.stderr, columns={})

        self.assertRaises(yappi.YappiError, fs.print_all, columns={1: ("namee", 9)})
        self.assertRaises(yappi.YappiError, cs.print_all, columns={1: ("dd", 0)})
        self.assertRaises(yappi.YappiError, ts.print_all, columns={1: ("tidd", 0)})

    def test_basic(self):
        yappi.set_clock_type('wall')
        def dummy():
            pass
        def a():
            time.sleep(0.2)
        class Worker1(threading.Thread):
            def a(self):
                time.sleep(0.3)
            def run(self):
                self.a()
        yappi.start(builtins=False, profile_threads=True)

        c = Worker1()
        c.start()
        c.join()
        a()
        stats = yappi.get_func_stats()
        fsa1 = utils.find_stat_by_name(stats, 'Worker1.a')
        fsa2 = utils.find_stat_by_name(stats, 'a')
        self.assertTrue(fsa1 is not None)
        self.assertTrue(fsa2 is not None)
        self.assertTrue(fsa1.ttot > 0.2)
        self.assertTrue(fsa2.ttot > 0.1)
        tstats = yappi.get_thread_stats()
        self.assertEqual(len(tstats), 2)
        tsa = utils.find_stat_by_name(tstats, 'Worker1')
        tsm = utils.find_stat_by_name(tstats, '_MainThread')
        dummy() # call dummy to force ctx name to be retrieved again.
        self.assertTrue(tsa is not None)
        # TODO: I put dummy() to fix below, remove the comments after a while.
        self.assertTrue( # FIX: I see this fails sometimes?
            tsm is not None, 
            'Could not find "_MainThread". Found: %s' % (', '.join(utils.get_stat_names(tstats)))) 

    def test_callback(self):
        self.context_id = 0
        yappi.set_context_id_callback(lambda: self.context_id)
        yappi.start()
        a()
        self.context_id = 1
        a()
        self.context_id = 2
        a()

        # Re-schedule context 1.
        self.context_id = 1
        a()
        yappi.stop()

        threadstats = yappi.get_thread_stats().sort('id', 'ascending')
        self.assertEqual(3, len(threadstats))
        self.assertEqual(0, threadstats[0].id)
        self.assertEqual(1, threadstats[1].id)
        self.assertEqual(2, threadstats[2].id)

        self.assertEqual(1, threadstats[0].sched_count)
        self.assertEqual(2, threadstats[1].sched_count)  # Context 1 ran twice.
        self.assertEqual(1, threadstats[2].sched_count)

        funcstats = yappi.get_func_stats()
        self.assertEqual(4, utils.find_stat_by_name(funcstats, 'a').ncall)

    def test_basic(self):
        import threading
        import time
        yappi.set_clock_type('wall')
        def a():
            time.sleep(0.2)
        class Worker1(threading.Thread):
            def a(self):
                time.sleep(0.3)                
            def run(self):
                self.a()
        yappi.start(builtins=False, profile_threads=True)

        c = Worker1()
        c.start()
        c.join()        
        a()
        stats = yappi.get_func_stats()
        fsa1 = utils.find_stat_by_name(stats, 'Worker1.a')
        fsa2 = utils.find_stat_by_name(stats, 'a')
        self.assertTrue(fsa1 is not None)
        self.assertTrue(fsa2 is not None)
        self.assertTrue(fsa1.ttot > 0.2)
        self.assertTrue(fsa2.ttot > 0.1)
        tstats = yappi.get_thread_stats()
        self.assertEqual(len(tstats), 2)
        tsa = utils.find_stat_by_name(tstats, 'Worker1')
        tsm = utils.find_stat_by_name(tstats, '_MainThread')
        self.assertTrue(tsa is not None)
        self.assertTrue(tsm is not None) # FIX: I see this fails sometimes?

 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_pause_resume(self):
        yappi.set_context_id_callback(lambda: self.context_id)
        yappi.set_clock_type('wall')

        # Start in context 0.
        self.context_id = 0
        yappi.start()
        time.sleep(0.08)

        # Switch to context 1.
        self.context_id = 1
        time.sleep(0.05)

        # Switch back to context 0.
        self.context_id = 0
        time.sleep(0.07)

        yappi.stop()

        t_stats = yappi.get_thread_stats().sort('id', 'ascending')
        self.assertEqual(2, len(t_stats))
        self.assertEqual(0, t_stats[0].id)
        self.assertEqual(2, t_stats[0].sched_count)
        self.assertTrue(0.15 < t_stats[0].ttot < 0.3)

        self.assertEqual(1, t_stats[1].id)
        self.assertEqual(1, t_stats[1].sched_count)
        # Context 1 was first scheduled 0.08 sec after context 0.
        self.assertTrue(0.1 < t_stats[1].ttot < 0.2 )

 def test_start_flags(self):
     self.assertEqual(_yappi._get_start_flags(), None)
     yappi.start()
     def a(): pass
     a()
     self.assertEqual(_yappi._get_start_flags()["profile_builtins"], 0)
     self.assertEqual(_yappi._get_start_flags()["profile_multithread"], 1)
     self.assertEqual(len(yappi.get_thread_stats()), 1) 

 def teardown_profiler(self):
     if not self.is_profiling():
         return
     path = os.environ["DRIVE_YAPPI"]
     if not os.path.exists(path):
         os.mkdir(path)
     report_path = os.path.join(path, self.id() + '-yappi-threads')
     with open(report_path, 'w') as fd:
         columns = {0: ("name", 80), 1: ("tid", 15), 2: ("ttot", 8), 3: ("scnt", 10)}
         yappi.get_thread_stats().print_all(out=fd, columns=columns)
     report_path = os.path.join(path, self.id() + '-yappi-fcts')
     with open(report_path, 'w') as fd:
         columns = {0: ("name", 80), 1: ("ncall", 5), 2: ("tsub", 8), 3: ("ttot", 8), 4: ("tavg", 8)}
         stats = yappi.get_func_stats()
         stats.strip_dirs()
         stats.print_all(out=fd, columns=columns)
     log.debug("Profiler Report generated in '%s'", report_path)

 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 sys_exit_call(signum, frame):
    print "profiling result:"
    yappi.get_func_stats().print_all(columns={0:("name",100), 1:("ncall", 15), 
                    2:("tsub", 8), 3:("ttot", 8), 4:("tavg",8)})
    yappi.get_thread_stats().print_all()
    sys.exit(1)

if __name__ == "__main__":
    if DEBUG:
        sys.argv.append("-h")
    if TESTRUN:
        import doctest
        doctest.testmod()
    if PROFILE:
        import pstats
        #Use yappi in multithreaded context
        import yappi
        yappi.start()
        exit_code = main()
        yappi.stop()
        stats = yappi.get_func_stats()
        tstats = yappi.get_thread_stats()
        STAT_FILE = 'profile_stats{}' 
        stats.save(STAT_FILE.format('.pstat'), type='pstat')
        
        with open(STAT_FILE.format('.txt'), 'w') as fh :
            # pstat format better than yappi format
            ps = pstats.Stats(STAT_FILE.format('.pstat'), stream = fh)
            ps.sort_stats('time')
            ps.print_stats()
            ps.sort_stats('cumulative')
            ps.print_stats()
            #append thread stats
            tstats.print_all(out = fh)
            #add function stat with yappi format
            stats.print_all(out=fh)