From 69721092c033f1c69060d2a5ae865f72a862e583 Mon Sep 17 00:00:00 2001 From: Andrew Geissler Date: Fri, 23 Jul 2021 12:57:00 -0400 Subject: meta-openembedded: subtree update:2449e5f07a..8fbcfb9f02 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adrian Zaharia (1): ntp: fix ntpdate to wait for subprocesses Akifumi Chikazawa (1): openvpn: add CVE-2020-7224 and CVE-2020-27569 to allowlist Andrea Adami (3): initramfs-kexecboot-image: support cases where machines override IMAGE_FSTYPES initramfs-debug-image: support cases where machines override IMAGE_FSTYPES rapidjson: remove stale LIB_INSTALL_DIR Andreas Müller (50): poppler: upgrade 21.05.0 -> 21.06.0 dbus-broker: upgrade 28 -> 29 libmbim: upgrade 1.24.6 -> 1.24.8 icewm: upgrade 2.3.3 -> 2.3.4 poppler: upgrade 21.06.0 -> 21.06.1 gnome-disk-utility: upgrade 3.36.3 -> 40.1 gnome-font-viewer: upgrade 3.34.0 -> 40.0 pipewire: upgrade 0.3.24 -> 0.3.29 libqmi: upgrade 1.28.4 -> 1.28.6 ttf-noto-emoji: upgrade 20190815 -> 20200916 remmina: upgrade 1.4.17 -> 1.4.18 metacity: upgrade 3.36.1 -> 3.40.0 gnome-flashback: upgrade 3.36.3 -> 3.40.0 gthumb: initial add 3.10.3 atkmm: upgrade 2.28.0 -> 2.28.2 atkmm: build with meson dconf: upgrade 0.38.0 -> 0.40.0 evolution-data-server: upgrade 3.40.1 -> 3.40.2 file-roller: upgrade 3.38.1 -> 3.40.0 glibmm: upgrade 2.62.0 -> 2.66.1 / build with meson / cleanup recipe gmime: upgrade 3.2.6 -> 3.2.7 gnome-autoar; upgrade 0.3.2 -> 0.3.3 gnome-keyring: upgrade 3.36.0 -> 40.0 gnome-online-accounts: upgrade 3.36.0 -> 3.40.0 gnome-terminal: upgrade 3.36.2 -> 3.40.2 gspell: upgrade 1.8.4 -> 1.9.1 gtkmm3: upgrade 3.24.3 -> 3.24.5 gtksourceview4: upgrade 4.6.1 -> 4.8.1 gupnp: upgrade 1.2.6 -> 1.2.7 gvfs: upgrade 1.44.1 -> 1.48.1 libgdata: upgrade 0.17.13 -> 0.18.1 libmediaart 0.7.0: remove libmediaart-2.0: upgrade 1.9.4 -> 1.9.5 / merge inc file / build with meson libsigc++-2.0: upgrade 2.10.6 -> 2.10.7 nautilus: upgrade 40.1 -> 40.2 pangomm: upgrade 2.42.1 -> 2.46.1 / build with meson yelp-xsl: upgrade 3.36.0 -> 4.02 yelp-tools: upgrade 3.32.2 -> 40.0 yelp: upgrade 3.36.0 -> 40.2 modemmanager: upgrade 1.16.4 -> 1.16.6 xfce4-settings: 4.16.1 upgrade 4.16.2 blueman: upgrade 2.1.4 -> 2.2.1 pipewire: upgrade 0.3.30 -> 0-3-31 cmark: upgrade 0.29.0 -> 0.30.0 networkmanager: upgrade 1.30.4 -> 1.32.2 ristretto: upgrade 0.10.0 -> 0.11.0 libgusb: upgrade 0.3.6 -> 0.3.7 poppler: upgrade 21.06.1 -> 21.07.0 gegl: Disable pango on native build to fix gimp build segfaults gimp: remove --disable-vector-icons Bartosz Golaszewski (13): libgpiod: coding style fixes libgpiod: list all packages in a single assignment libgpiod: fix RRECOMMENDS for python bindings libgpiod: correctly split output files into packages libgpiod: add RDEPENDS for tests libgpiod: redirect stdout from the ptest executable to a file libgpiod: ptest: run all test-suites if possible libgpiod: ptest: warn if the gpio-mockup kernel module is not selected libgpiod: ptest: add kernel-modules to RRECOMMENDS libgpiod: ptest: only rrecommend a single module that we need libgpiod: add the python test-suite to the ptest package libgpiod: update my email address python3-joblib: new package Ben Horgan (1): cpputest: Add initial recipe. Version 4.0. Carlos Rafael Giani (2): pipewire: Add filter-chain files to modules-filter-chain package pipewire: Upgrade to 0.3.30 Changqing Li (1): mousepad: fix warning during postinst Chen Qi (1): minifi-cpp: set CLEANBROKEN to 1 Daiane Angolini (1): wireguard-module: Stop overriding modules_install in the recipe Daniel Klauer (1): spidev-test: Update common-licenses reference David Sterling (1): can-isotp: Upgrade to latest on master Ed Tanous (1): Use the built-in options for removing pack tools Geoff Parker (1): cifs-utils: set ROOTSBINDIR to /usr/sbin if DISTRO_FEATURES has usrmerge Gianfranco (2): vboxguestdrivers: add a fix for build failure with kernel 5.13 dlt-daemon: update from 2.18.6 to 2.18.7 Hongxu Jia (1): debootstrap: fix runtime failure on nativesdk Joshua Watt (1): gnome: gnome-shell: Move gsettings to their own package Kai Kang (4): python3-m2crypto: fix word size for qemuppc64 little endian python3-m2crypto: avoid host contamination for swig bats: fix qa issue when multilib eanbled mariadb: fix failures to start install_db.service Khem Raj (57): glog: Upgrade to 0.5.0 mbedtls: Upgrade to 2.26.0 mbedtls: Add packageconfig for warning-as-errors memcached: upgrade to 1.6.9 indent: Remove dead code using count_parens function glm: Fix additional clang warnings tbb: Fix warnings with clang libwebsockets: Update to latest on v4.2-stable packagegroup-meta-oe: Add libparse-yapp-perl netplan: Fix a warning with clang python3-yappi: Fix patching errors packagegroup-meta-oe: Add zsync-curl klibc: Add clang's -rtlib to known options libpfm4: Upgrade to 4.11.0 ltrace: Remove unused static function flashrom: Fix build with clang mongodb: Enable wiredtiger only on aarch64/x86_64 hosts mariadb: Fix build with clang/musl c-ares: Upgrade to 1.17.1 release nodejs: Update to 14.17.1 rocksdb: Upgrade to 6.20.3 rocksdb: Implement toku_time_now function for rv32/rv64 rocksdb: Fix build with ppc64/musl rocksdb: Implement timer for mips rocksdb: Implement timer for armv6+ rocksdb: Fix build with gcc on rv32 and mips libzip: Upgrade to 1.8.0 czmq: Inherit pkgconfig czmq: Add libmicrohttpd feature via packageconfig czmq: Use Cmake knobs to enable/disable designed packageconfigs czmq: Add nss packageconfig meta-python: Add python3-fastjsonschema and its dependencies packagegroup-meta-python: Add newly added recipes python3-process-tests: Add recipe python3-aspectlib: Add ptests python3-execnet: Add ptests python3-py-cpuinfo: Add ptests libc-bench: Do not override ldflags in makefile mpich: Add libgcc to ldflags on x86/glibc mpd: Update to 0.22.9 imlib2: Use propert git SHA in SRCREV suitesparse: Update to 5.10.1 packagegroup-meta-oe: Add libyang sysdig: Disable JIT on ppc64 portaudio-v19: Use GNUInstallDirs to make it portable keepalived: Upgrade to 2.2.2 suitesparse: Fix LIC_FILES_CHKSUM xscreensaver: Update to 6.01 ltrace: Fix mips build with kernels 5.13+ python3-pyusb: Add missing runtime dependency on libusb1 can-isotp: Ignore in world builds postfix: Upgrade to 3.6.1 packagegroup-meta-oe: Add new package cpputest apitrace: Update to latest trunk fatresize: Disable building documentation files layers: Fix git send-email instructions in README autofs: Upgrade to 5.1.7 Leon Anavi (61): python3-oauthlib: Upgrade 3.1.0 -> 3.1.1 python3-django: Upgrade 3.2.3 -> 3.2.4 python3-sqlalchemy: Upgrade 1.4.15 -> 1.4.17 python3-aiohue: Upgrade 2.5.0 -> 2.5.1 python3-typeguard: Upgrade 2.12.0 -> 2.12.1 python3-cbor2: Upgrade 5.3.0 -> 5.4.0 python3-ipython: Upgrade 7.24.0 -> 7.24.1 python3-pkgconfig: Upgrade 1.5.2 -> 1.5.4 python3-humanize: Upgrade 3.6.0 -> 3.7.1 python3-fasteners: Upgrade 0.16 -> 0.16.1 python3-pythonping: Upgrade 1.0.16 -> 1.1.0 python3-bitarray: Upgrade 2.1.0 -> 2.1.2 python3-coloredlogs: Upgrade 15.0 -> 15.0.1 python3-pysonos: Upgrade 0.0.50 -> 0.0.51 python3-dill: Upgrade 0.3.3 -> 0.3.4 python3-humanfriendly: Upgrade 9.1 -> 9.2 python3-zeroconf: Add recipe python3-pychromecast: Upgrade 9.1.2 -> 9.2.0 python3-ifaddr: Fix RDEPENDS python3-bitarray: Upgrade 2.1.2 -> 2.1.3 python3-astroid: Upgrade 2.5.7 -> 2.5.8 python3-license-expression: Upgrade 1.2 -> 21.6.14 python3-humanize: Upgrade 3.7.1 -> 3.9.0 python3-ruamel-yaml: Upgrade 0.17.7 -> 0.17.9 python3-cmd2: Upgrade 1.5.0 -> 2.1.1 python3-fasteners: Upgrade 0.16.1 -> 0.16.3 python3-elementpath: Upgrade 2.2.2 -> 2.2.3 python3-prompt-toolkit: Upgrade 3.0.18 -> 3.0.19 python3-mypy: Upgrade 0.812 -> 0.902 python3-send2trash: Upgrade 1.5.0 -> 1.7.1 python3-pandas: Upgrade 1.2.4 -> 1.2.5 python3-mypy: Upgrade 0.902 -> 0.910 python3-astroid: Upgrade 2.5.8 -> 2.6.0 python3-tqdm: Upgrade 4.61.0 -> 4.61.1 python3-ruamel-yaml: Upgrade 0.17.9 -> 0.17.10 python3-httplib2: Fix runtime dependencies python3-google-api-core: Add recipe python3-google-auth: Add recipe python3-googleapis-common-protos: Add recipe python3-google-api-python-client: Upgrade 2.6.0 -> 2.10.0 python3-ipython: Upgrade 7.24.1 -> 7.25.0 python3-croniter: Upgrade 1.0.13 -> 1.0.15 python3-priority: Upgrade 1.3.0 -> 2.0.0 python3-astroid: Upgrade 2.6.0 -> 2.6.2 python3-watchdog: Upgrade 2.1.2 -> 2.1.3 python3-humanize: Upgrade 3.9.0 -> 3.10.0 python3-pillow: Upgrade 8.2.0 -> 8.3.1 python3-bitarray: Upgrade 2.1.3 -> 2.2.1 python3-cmd2: Upgrade 2.1.1 -> 2.1.2 python3-pandas: Upgrade 1.2.5 -> 1.3.0 python3-texttable: Upgrade 1.6.3 -> 1.6.4 python3-dateutil: Upgrade 2.8.1 -> 2.8.2 python3-requests: Upgrade 2.25.1 -> 2.26.0 python3-websocket-client: Upgrade 1.0.1 -> 1.1.0 python3-pysonos: Upgrade 0.0.51 -> 0.0.53 python3-bitarray: Upgrade 2.2.1 -> 2.2.2 python3-pyusb: Upgrade 1.2.0 -> 1.2.1 python3-zeroconf: Upgrade 0.31.0 -> 0.33.1 python3-yamlloader: Upgrade 1.0.0 -> 1.1.0 python3-astroid: Upgrade 2.6.2 -> 2.6.5 python3-pkgconfig: Upgrade 1.5.4 -> 1.5.5 Luan Rafael Carneiro (1): libwebsockets: Update 4.2.0 -> 4.2.1 Luca Boccassi (2): dbus-broker: remove deprecated linux-4-17 option dbus-broker: enforce required versions of libselinux and libaudit Marek Vasut (1): nss: Fix build on Centos 7 Martin Jansa (1): rygel: require gobject-introspection-data in DISTRO_FEATURES Masaki Ambai (1): nss: add CVE-2006-5201 to allowlist Oleksandr Kravchuk (1): iwd: update to 1.15 Olivier Georget (1): libpfm4 4.10.1 : enable arm64 host platform Ovidiu Panait (1): libeigen: update LICENSE information Pascal Bach (1): python3-thrift: support native recipe Persian Prince (1): samba: Don't guess dirs for perllocal.pod removing Peter Bergin (4): linuxptp: use install from makefile and install more apps linuxptp: add homepage linuxptp: ship example configurations in separate package hiredis: add cmake config file for pkgconfig Peter Kjellerstedt (3): net-snmp: A little clean up net-snmp: Support building for native cryptsetup: Only recommend kernel modules when building for target Philip Balister (1): fftw: Update recipe to 3.3.9. Pierre-Jean Texier (5): libtinyxml2: upgrade 8.1.0 -> 9.0.0 sshfs-fuse: upgrade 3.7.1 -> 3.7.2 monit: upgrade 5.27.2 -> 5.28.0 spitools: upgrade 0.8.7 -> 1.0.0 linuxptp: fix upstream version check Ross Burton (1): zsync-curl: add recipe Sam Van Den Berge (1): libiio: fix installing libiio when python3 bindings are enabled Sekine Shigeki (2): add CVE-2011-2411 to allowlist ntp: add CVE-2016-9312 to allowlist Signed-off-by: Bartosz Golaszewski (1): Revert "libgpiod: ptest: warn if the gpio-mockup kernel module is not selected" Tim Orling (8): libcgi-perl: upgrade 4.51 -> 4.53 libcrypt-openssl-guess-perl: upgrade 0.12 -> 0.13 libextutils-cppguess-perl: upgrade 0.21 -> 0.23 libio-socket-ssl-perl: upgrade 2.068 -> 2.071 libmoo-perl: upgrade 2.004000 -> 2.005004 libnet-dns-perl: upgrade 1.26 -> 1.31 libtest-warnings-perl: upgrade 0.028 -> 0.030 logcheck: upgrade 1.3.20 -> 1.3.23 Tony Tascioglu (2): libyang: create recipe for libyang redis: upgrade to 6.2.4 Trevor Gamblin (9): libnftnl: upgrade 1.1.9 -> 1.2.0 nftables: upgrade 0.9.8 -> 0.9.9 python3-yarl: backport fix for test_url_query test python3-yappi: fix ptests python3-django: upgrade 2.2.23 -> 2.2.24 python3-django: upgrade 3.2.4 -> 3.2.5 python3-geomet: add recipe python3-cassandra-driver: add geomet to RDEPENDS, remove DISTUTILS options python3-geomet: Add missing RDEPENDS; add to packagegroup-meta-python Yi Zhao (14): libldb: upgrade 1.5.8 -> 2.3.0 samba: upgrade 4.10.18 -> 4.14.4 samba: update smb.conf libparse-yapp-perl: add recipe dhcp-relay: update bundled bind to 9.11.32 dhcp-relay: disable backtrace in bundled bind dhcp-relay: update 4.4.2 -> 4.4.2-P1 packagegroup-meta-networking: add dhcp-relay samba: disable check fcntl RW_HINTS when configure samba: upgrade 4.14.4 -> 4.14.5 minifi-cpp: set correct python processor directory in configure file samba: fix shebang for pidl samba: add missing runtime dependency for pidl audit: upgrade 3.0.1 -> 3.0.2 Zoltán Böszörményi (2): mariadb: Use qemu to run cross-compiled binaries mariadb: Upgrade to 10.5.11 hayashi.satoshi@fujitsu.com (1): dracut: add CVE-2010-4176 to allowlist ito-yuichi@fujitsu.com (2): cyrus-sasl: add CVE-2020-8032 to allowlist dovecot: add CVE-2016-4983 to allowlist massimo toscanelli (1): sysbench: fix memory test wangmy (8): samba: Solve the dependency problem when installing Samba fatresize: upgrade 1.0.2 -> 1.1.0 xfsprogs: upgrade 5.10.0 -> 5.12.0 ctags: upgrade 5.9.20210627.0 -> 5.9.20210711.0 icewm: upgrade 2.3.4 -> 2.6.0 yelp: upgrade 40.2 -> 40.3 live555: upgrade 20210406 -> 20210710 modemmanager: upgrade 1.16.6 -> 1.16.8 zangrc (49): python3-idna: upgrade 3.1 -> 3.2 netplan: upgrade 0.101 -> 0.102 wireshark: upgrade 3.4.5 -> 3.4.6 tracker: upgrade 3.0.4 -> 3.1.1 tracker-miners: upgrade 3.0.5 -> 3.1.1 rasdaemon: upgrade 0.6.6 -> 0.6.7 speedtest-cli: upgrade 2.1.2 -> 2.1.3 abseil-cpp: upgrade 20210324 -> 20210324.2 cryptsetup: upgrade 2.3.5 -> 2.3.6 ctags: upgrade 5.9.20210502.0 -> 5.9.20210606.0 opencl-clhpp: upgrade 2.0.13 -> 2.0.14 protobuf: upgrade 3.17.0 -> 3.17.3 toybox: upgrade 0.8.4 -> 0.8.5 fuse3: upgrade 3.10.3 -> 3.10.4 evince: upgrade 40.1 -> 40.2 mosquitto: upgrade 2.0.10 -> 2.0.11 ctags: upgrade 5.9.20210606.0 -> 20210613.0 fsverity-utils: upgrade 1.3 -> 1.4 googletest: upgrade 1.10.0 -> 1.11.0 mg: upgrade 20210314 -> 20210609 nano: upgrade 5.7 -> 5.8 openvpn: upgrade 2.5.2 -> 2.5.3 snort: upgrade 2.9.17.1 -> 2.9.18 function2: upgrade 4.1.0 -> 4.2.0 python3-configargparse: upgrade 1.4.1 -> 1.5 python3-grpcio-tools: upgrade 1.37.0 -> 1.38.1 python3-h5py: upgrade 3.2.1 -> 3.3.0 python3-isort: upgrade 5.8.0 -> 5.9.1 can-utils: upgrade 2020.12.0 -> 2021.06.0 ctags: upgrade 5.9.20210620.0 -> 5.9.20210627.0 python3-gast: upgrade 0.4.0 -> 0.5.0 python3-grpcio: upgrade 1.38.0 -> 1.38.1 python3-haversine: upgrade 2.3.0 -> 2.3.1 python3-m2crypto: upgrade 0.37.1 -> 0.38.0 python3-pyrsistent: upgrade 0.17.3 -> 0.18.0 babl: upgrade 0.1.86 -> 0.1.88 python3-pyusb: upgrade 1.1.1 -> 1.2.0 python3-google-api-python-client: upgrade 2.10.0 -> 2.12.0 firewalld: upgrade 0.9.3 -> 0.9.4 strongswan: upgrade 5.9.2 -> 5.9.3 opencl-clhpp: upgrade 2.0.14 -> 2.0.15 python3-cffi: upgrade 1.14.5 -> 1.14.6 python3-configargparse: upgrade 1.5 -> 1.5.1 python3-cryptography-vectors: upgrade 3.4.6 -> 3.4.7 python3-flask-migrate: upgrade 3.0.0 -> 3.0.1 python3-flask-socketio: upgrade 5.0.3 -> 5.1.0 python3-isort: upgrade 5.9.1 -> 5.9.2 python3-networkx: upgrade 2.5.1 -> 2.6.1 python3-gnupg: upgrade 0.4.6 -> 0.4.7 zhengruoqin (30): opensaf: upgrade 5.21.03 -> 5.21.06 fio: upgrade 3.26 -> 3.27 gensio: upgrade 2.2.5 -> 2.2.7 memtester: upgrade 4.5.0 -> 4.5.1 graphene: upgrade 1.10.2 -> 1.10.6 iozone3: upgrade 490 -> 492 net-snmp: upgrade 5.9 -> 5.9.1 rsnapshot: upgrade 1.4.3 -> 1.4.4 rsyslog: upgrade 8.2104.0 -> 8.2106.0 python3-absl: upgrade 0.12.0 -> 0.13.0 ctags: upgrade 5.9.20210613.0 -> 5.9.20210620.0 fwts: upgrade 21.03.00 -> 21.06.00 grpc: upgrade 1.38.0 -> 1.38.1 libconfig: upgrade 1.7.2 -> 1.7.3 satyr: upgrade 0.37 -> 0.38 libnet-telnet-perl: upgrade 3.04 -> 3.05 python3-scrypt: upgrade 0.8.17 -> 0.8.18 python3-urllib3: upgrade 1.26.5 -> 1.26.6 python3-sqlalchemy: upgrade 1.4.17 -> 1.4.20 python3-qrcode: upgrade 6.1 -> 7.1 python3-regex: upgrade 2021.4.4 -> 2021.7.6 python3-sentry-sdk: upgrade 1.1.0 -> 1.2.0 python3-tqdm: upgrade 4.61.1 -> 4.61.2 python3-xlsxwriter: upgrade 1.4.3 -> 1.4.4 ostree: upgrade 2021.2 -> 2021.3 span-lite: upgrade 0.9.2 -> 0.10.0 python3-pymisp: upgrade 2.4.143 -> 2.4.144 python3-protobuf: upgrade 3.17.0 -> 3.17.3 python3-pulsectl: upgrade 21.5.17 -> 21.5.18 python3-pytun: upgrade 2.3.0 -> 2.4.1 Signed-off-by: Andrew Geissler Change-Id: Ie45184e6f308aa2fc98ee6edf4a3ca1c4afbb5b4 --- .../0001-Fix-imports-for-ptests.patch | 3905 ++++++++++++++++++++ 1 file changed, 3905 insertions(+) create mode 100644 meta-openembedded/meta-python/recipes-devtools/python/python3-yappi/0001-Fix-imports-for-ptests.patch (limited to 'meta-openembedded/meta-python/recipes-devtools/python/python3-yappi') diff --git a/meta-openembedded/meta-python/recipes-devtools/python/python3-yappi/0001-Fix-imports-for-ptests.patch b/meta-openembedded/meta-python/recipes-devtools/python/python3-yappi/0001-Fix-imports-for-ptests.patch new file mode 100644 index 0000000000..fa58897e68 --- /dev/null +++ b/meta-openembedded/meta-python/recipes-devtools/python/python3-yappi/0001-Fix-imports-for-ptests.patch @@ -0,0 +1,3905 @@ +From 0dedc1c573ddc4e87475eb03c64555cd54a72e92 Mon Sep 17 00:00:00 2001 +From: Trevor Gamblin +Date: Mon, 7 Jun 2021 09:40:20 -0400 +Subject: [PATCH] Fix imports for tests + +Signed-off-by: Trevor Gamblin +--- + tests/test_asyncio.py | 2 +- + tests/test_asyncio_context_vars.py | 2 +- + tests/test_functionality.py | 2 +- + tests/test_gevent.py | 2 +- + tests/test_hooks.py | 2 +- + tests/test_tags.py | 2 +- + 6 files changed, 6 insertions(+), 6 deletions(-) + +--- a/tests/test_asyncio.py ++++ b/tests/test_asyncio.py +@@ -2,7 +2,7 @@ import unittest + import yappi + import asyncio + import threading +-from utils import YappiUnitTestCase, find_stat_by_name, burn_cpu, burn_io ++from .utils import YappiUnitTestCase, find_stat_by_name, burn_cpu, burn_io + + + @asyncio.coroutine +--- a/tests/test_asyncio_context_vars.py ++++ b/tests/test_asyncio_context_vars.py +@@ -5,7 +5,7 @@ import contextvars + import functools + import time + import os +-import utils ++import tests.utils as utils + import yappi + + async_context_id = contextvars.ContextVar('async_context_id') +--- a/tests/test_functionality.py ++++ b/tests/test_functionality.py +@@ -1,1916 +1,1916 @@ +-import os +-import sys +-import time +-import threading +-import unittest +-import yappi +-import _yappi +-import utils +-import multiprocessing # added to fix http://bugs.python.org/issue15881 for > Py2.6 +-import subprocess +- +-_counter = 0 +- +- +-class BasicUsage(utils.YappiUnitTestCase): +- +- def test_callback_function_int_return_overflow(self): +- # this test is just here to check if any errors are generated, as the err +- # is printed in C side, I did not include it here. THere are ways to test +- # this deterministically, I did not bother +- import ctypes +- +- def _unsigned_overflow_margin(): +- return 2**(ctypes.sizeof(ctypes.c_void_p) * 8) - 1 +- +- def foo(): +- pass +- +- #with utils.captured_output() as (out, err): +- yappi.set_context_id_callback(_unsigned_overflow_margin) +- yappi.set_tag_callback(_unsigned_overflow_margin) +- yappi.start() +- foo() +- +- def test_issue60(self): +- +- def foo(): +- buf = bytearray() +- buf += b't' * 200 +- view = memoryview(buf)[10:] +- view = view.tobytes() +- del buf[:10] # this throws exception +- return view +- +- yappi.start(builtins=True) +- foo() +- self.assertTrue( +- len( +- yappi.get_func_stats( +- filter_callback=lambda x: yappi. +- func_matches(x, [memoryview.tobytes]) +- ) +- ) > 0 +- ) +- yappi.stop() +- +- def test_issue54(self): +- +- def _tag_cbk(): +- global _counter +- _counter += 1 +- return _counter +- +- def a(): +- pass +- +- def b(): +- pass +- +- yappi.set_tag_callback(_tag_cbk) +- yappi.start() +- a() +- a() +- a() +- yappi.stop() +- stats = yappi.get_func_stats() +- self.assertEqual(stats.pop().ncall, 3) # aggregated if no tag is given +- stats = yappi.get_func_stats(tag=1) +- +- for i in range(1, 3): +- stats = yappi.get_func_stats(tag=i) +- stats = yappi.get_func_stats( +- tag=i, filter_callback=lambda x: yappi.func_matches(x, [a]) +- ) +- +- stat = stats.pop() +- self.assertEqual(stat.ncall, 1) +- +- yappi.set_tag_callback(None) +- yappi.clear_stats() +- yappi.start() +- b() +- b() +- stats = yappi.get_func_stats() +- self.assertEqual(len(stats), 1) +- stat = stats.pop() +- self.assertEqual(stat.ncall, 2) +- +- def test_filter(self): +- +- def a(): +- pass +- +- def b(): +- a() +- +- def c(): +- b() +- +- _TCOUNT = 5 +- +- ts = [] +- yappi.start() +- for i in range(_TCOUNT): +- t = threading.Thread(target=c) +- t.start() +- ts.append(t) +- +- for t in ts: +- t.join() +- +- yappi.stop() +- +- ctx_ids = [] +- for tstat in yappi.get_thread_stats(): +- if tstat.name == '_MainThread': +- main_ctx_id = tstat.id +- else: +- ctx_ids.append(tstat.id) +- +- fstats = yappi.get_func_stats(filter={"ctx_id": 9}) +- self.assertTrue(fstats.empty()) +- fstats = yappi.get_func_stats( +- filter={ +- "ctx_id": main_ctx_id, +- "name": "c" +- } +- ) # main thread +- self.assertTrue(fstats.empty()) +- +- for i in ctx_ids: +- fstats = yappi.get_func_stats( +- filter={ +- "ctx_id": i, +- "name": "a", +- "ncall": 1 +- } +- ) +- self.assertEqual(fstats.pop().ncall, 1) +- fstats = yappi.get_func_stats(filter={"ctx_id": i, "name": "b"}) +- self.assertEqual(fstats.pop().ncall, 1) +- fstats = yappi.get_func_stats(filter={"ctx_id": i, "name": "c"}) +- self.assertEqual(fstats.pop().ncall, 1) +- +- yappi.clear_stats() +- yappi.start(builtins=True) +- time.sleep(0.1) +- yappi.stop() +- fstats = yappi.get_func_stats(filter={"module": "time"}) +- self.assertEqual(len(fstats), 1) +- +- # invalid filters` +- self.assertRaises( +- Exception, yappi.get_func_stats, filter={'tag': "sss"} +- ) +- self.assertRaises( +- Exception, yappi.get_func_stats, filter={'ctx_id': "None"} +- ) +- +- def test_filter_callback(self): +- +- def a(): +- time.sleep(0.1) +- +- def b(): +- a() +- +- def c(): +- pass +- +- def d(): +- pass +- +- yappi.set_clock_type("wall") +- yappi.start(builtins=True) +- a() +- b() +- c() +- d() +- stats = yappi.get_func_stats( +- filter_callback=lambda x: yappi.func_matches(x, [a, b]) +- ) +- #stats.print_all() +- r1 = ''' +- tests/test_functionality.py:98 a 2 0.000000 0.200350 0.100175 +- tests/test_functionality.py:101 b 1 0.000000 0.120000 0.100197 +- ''' +- self.assert_traces_almost_equal(r1, stats) +- self.assertEqual(len(stats), 2) +- stats = yappi.get_func_stats( +- filter_callback=lambda x: yappi. +- module_matches(x, [sys.modules[__name__]]) +- ) +- r1 = ''' +- tests/test_functionality.py:98 a 2 0.000000 0.230130 0.115065 +- tests/test_functionality.py:101 b 1 0.000000 0.120000 0.109011 +- tests/test_functionality.py:104 c 1 0.000000 0.000002 0.000002 +- tests/test_functionality.py:107 d 1 0.000000 0.000001 0.000001 +- ''' +- self.assert_traces_almost_equal(r1, stats) +- self.assertEqual(len(stats), 4) +- +- stats = yappi.get_func_stats( +- filter_callback=lambda x: yappi.func_matches(x, [time.sleep]) +- ) +- self.assertEqual(len(stats), 1) +- r1 = ''' +- time.sleep 2 0.206804 0.220000 0.103402 +- ''' +- self.assert_traces_almost_equal(r1, stats) +- +- 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_get_clock(self): +- yappi.set_clock_type('cpu') +- self.assertEqual('cpu', yappi.get_clock_type()) +- clock_info = yappi.get_clock_info() +- self.assertTrue('api' in clock_info) +- self.assertTrue('resolution' in clock_info) +- +- yappi.set_clock_type('wall') +- self.assertEqual('wall', yappi.get_clock_type()) +- +- t0 = yappi.get_clock_time() +- time.sleep(0.1) +- duration = yappi.get_clock_time() - t0 +- self.assertTrue(0.05 < duration < 0.3) +- +- def test_profile_decorator(self): +- +- def aggregate(func, stats): +- fname = "tests/%s.profile" % (func.__name__) +- try: +- stats.add(fname) +- except IOError: +- pass +- stats.save(fname) +- raise Exception("messing around") +- +- @yappi.profile(return_callback=aggregate) +- def a(x, y): +- if x + y == 25: +- raise Exception("") +- return x + y +- +- def b(): +- pass +- +- try: +- os.remove( +- "tests/a.profile" +- ) # remove the one from prev test, if available +- except: +- pass +- +- # global profile is on to mess things up +- yappi.start() +- b() +- +- # assert functionality and call function at same time +- try: +- self.assertEqual(a(1, 2), 3) +- except: +- pass +- try: +- self.assertEqual(a(2, 5), 7) +- except: +- pass +- try: +- a(4, 21) +- except: +- pass +- stats = yappi.get_func_stats().add("tests/a.profile") +- fsa = utils.find_stat_by_name(stats, 'a') +- self.assertEqual(fsa.ncall, 3) +- self.assertEqual(len(stats), 1) # b() should be cleared out. +- +- @yappi.profile(return_callback=aggregate) +- def count_down_rec(n): +- if n == 0: +- return +- count_down_rec(n - 1) +- +- try: +- os.remove( +- "tests/count_down_rec.profile" +- ) # remove the one from prev test, if available +- except: +- pass +- +- try: +- count_down_rec(4) +- except: +- pass +- try: +- count_down_rec(3) +- except: +- pass +- +- stats = yappi.YFuncStats("tests/count_down_rec.profile") +- fsrec = utils.find_stat_by_name(stats, 'count_down_rec') +- self.assertEqual(fsrec.ncall, 9) +- self.assertEqual(fsrec.nactualcall, 2) +- +- def test_strip_dirs(self): +- +- def a(): +- pass +- +- stats = utils.run_and_get_func_stats(a, ) +- stats.strip_dirs() +- fsa = utils.find_stat_by_name(stats, "a") +- self.assertEqual(fsa.module, os.path.basename(fsa.module)) +- +- @unittest.skipIf(os.name == "nt", "do not run on Windows") +- def test_run_as_script(self): +- import re +- p = subprocess.Popen( +- ['yappi', os.path.join('./tests', 'run_as_script.py')], +- stdout=subprocess.PIPE +- ) +- out, err = p.communicate() +- self.assertEqual(p.returncode, 0) +- func_stats, thread_stats = re.split( +- b'name\\s+id\\s+tid\\s+ttot\\s+scnt\\s*\n', out +- ) +- self.assertTrue(b'FancyThread' in thread_stats) +- +- def test_yappi_overhead(self): +- LOOP_COUNT = 100000 +- +- def a(): +- pass +- +- def b(): +- for i in range(LOOP_COUNT): +- a() +- +- t0 = time.time() +- yappi.start() +- b() +- yappi.stop() +- time_with_yappi = time.time() - t0 +- t0 = time.time() +- b() +- time_without_yappi = time.time() - t0 +- if time_without_yappi == 0: +- time_without_yappi = 0.000001 +- +- # in latest v0.82, I calculated this as close to "7.0" in my machine. +- # however, %83 of this overhead is coming from tickcount(). The other %17 +- # seems to have been evenly distributed to the internal bookkeeping +- # structures/algorithms which seems acceptable. Note that our test only +- # tests one function being profiled at-a-time in a short interval. +- # profiling high number of functions in a small time +- # is a different beast, (which is pretty unlikely in most applications) +- # So as a conclusion: I cannot see any optimization window for Yappi that +- # is worth implementing as we will only optimize %17 of the time. +- sys.stderr.write("\r\nYappi puts %0.1f times overhead to the profiled application in average.\r\n" % \ +- (time_with_yappi / time_without_yappi)) +- +- 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 test_generator(self): +- +- def _gen(n): +- while (n > 0): +- yield n +- n -= 1 +- +- yappi.start() +- for x in _gen(5): +- pass +- self.assertTrue( +- yappi.convert2pstats(yappi.get_func_stats()) is not None +- ) +- +- def test_slice_child_stats_and_strip_dirs(self): +- +- def b(): +- for i in range(10000000): +- pass +- +- def a(): +- b() +- +- yappi.start(builtins=True) +- a() +- stats = yappi.get_func_stats() +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- self.assertTrue(fsa.children[0:1] is not None) +- prev_afullname = fsa.full_name +- prev_bchildfullname = fsa.children[fsb].full_name +- stats.strip_dirs() +- self.assertTrue(len(prev_afullname) > len(fsa.full_name)) +- self.assertTrue( +- len(prev_bchildfullname) > len(fsa.children[fsb].full_name) +- ) +- +- def test_children_stat_functions(self): +- _timings = {"a_1": 5, "b_1": 3, "c_1": 1} +- _yappi._set_test_timings(_timings) +- +- def b(): +- pass +- +- def c(): +- pass +- +- def a(): +- b() +- c() +- +- yappi.start() +- a() +- b() # non-child call +- c() # non-child call +- stats = yappi.get_func_stats() +- fsa = utils.find_stat_by_name(stats, 'a') +- childs_of_a = fsa.children.get().sort("tavg", "desc") +- prev_item = None +- for item in childs_of_a: +- if prev_item: +- self.assertTrue(prev_item.tavg > item.tavg) +- prev_item = item +- childs_of_a.sort("name", "desc") +- prev_item = None +- for item in childs_of_a: +- if prev_item: +- self.assertTrue(prev_item.name > item.name) +- prev_item = item +- childs_of_a.clear() +- self.assertTrue(childs_of_a.empty()) +- +- def test_no_stats_different_clock_type_load(self): +- +- def a(): +- pass +- +- yappi.start() +- a() +- yappi.stop() +- yappi.get_func_stats().save("tests/ystats1.ys") +- yappi.clear_stats() +- yappi.set_clock_type("WALL") +- yappi.start() +- yappi.stop() +- stats = yappi.get_func_stats().add("tests/ystats1.ys") +- fsa = utils.find_stat_by_name(stats, 'a') +- self.assertTrue(fsa is not None) +- +- def test_subsequent_profile(self): +- _timings = {"a_1": 1, "b_1": 1} +- _yappi._set_test_timings(_timings) +- +- def a(): +- pass +- +- def b(): +- pass +- +- yappi.start() +- a() +- yappi.stop() +- yappi.start() +- b() +- yappi.stop() +- stats = yappi.get_func_stats() +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- self.assertTrue(fsa is not None) +- self.assertTrue(fsb is not None) +- self.assertEqual(fsa.ttot, 1) +- self.assertEqual(fsb.ttot, 1) +- +- def test_lambda(self): +- f = lambda: time.sleep(0.3) +- yappi.set_clock_type("wall") +- yappi.start() +- f() +- stats = yappi.get_func_stats() +- fsa = utils.find_stat_by_name(stats, '') +- self.assertTrue(fsa.ttot > 0.1) +- +- 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_stat_sorting(self): +- _timings = {"a_1": 13, "b_1": 10, "a_2": 6, "b_2": 1} +- _yappi._set_test_timings(_timings) +- +- self._ncall = 1 +- +- def a(): +- b() +- +- def b(): +- if self._ncall == 2: +- return +- self._ncall += 1 +- a() +- +- stats = utils.run_and_get_func_stats(a) +- stats = stats.sort("totaltime", "desc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.ttot >= stat.ttot) +- prev_stat = stat +- stats = stats.sort("totaltime", "asc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.ttot <= stat.ttot) +- prev_stat = stat +- stats = stats.sort("avgtime", "asc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.tavg <= stat.tavg) +- prev_stat = stat +- stats = stats.sort("name", "asc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.name <= stat.name) +- prev_stat = stat +- stats = stats.sort("subtime", "asc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.tsub <= stat.tsub) +- prev_stat = stat +- +- self.assertRaises( +- yappi.YappiError, stats.sort, "invalid_func_sorttype_arg" +- ) +- self.assertRaises( +- yappi.YappiError, stats.sort, "totaltime", +- "invalid_func_sortorder_arg" +- ) +- +- 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_multicontext"], 1) +- self.assertEqual(len(yappi.get_thread_stats()), 1) +- +- 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_singlethread_profiling(self): +- 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(profile_threads=False) +- +- 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 None) +- self.assertTrue(fsa2 is not None) +- self.assertTrue(fsa2.ttot > 0.1) +- +- 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 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')) +- +- +-class StatSaveScenarios(utils.YappiUnitTestCase): +- +- 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("tests/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("tests/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("tests/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("tests/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( +- 'tests/a1.pstats', 'tests/a2.pstats', 'tests/b1.pstats', +- 'tests/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) +- +- def test_merge_stats(self): +- _timings = { +- "a_1": 15, +- "b_1": 14, +- "c_1": 12, +- "d_1": 10, +- "e_1": 9, +- "f_1": 7, +- "g_1": 6, +- "h_1": 5, +- "i_1": 1 +- } +- _yappi._set_test_timings(_timings) +- +- def a(): +- b() +- +- def b(): +- c() +- +- def c(): +- d() +- +- def d(): +- e() +- +- def e(): +- f() +- +- def f(): +- g() +- +- def g(): +- h() +- +- def h(): +- i() +- +- def i(): +- pass +- +- yappi.start() +- a() +- a() +- yappi.stop() +- stats = yappi.get_func_stats() +- self.assertRaises( +- NotImplementedError, stats.save, "", "INVALID_SAVE_TYPE" +- ) +- stats.save("tests/ystats2.ys") +- yappi.clear_stats() +- _yappi._set_test_timings(_timings) +- yappi.start() +- a() +- stats = yappi.get_func_stats().add("tests/ystats2.ys") +- fsa = utils.find_stat_by_name(stats, "a") +- fsb = utils.find_stat_by_name(stats, "b") +- fsc = utils.find_stat_by_name(stats, "c") +- fsd = utils.find_stat_by_name(stats, "d") +- fse = utils.find_stat_by_name(stats, "e") +- fsf = utils.find_stat_by_name(stats, "f") +- fsg = utils.find_stat_by_name(stats, "g") +- fsh = utils.find_stat_by_name(stats, "h") +- fsi = utils.find_stat_by_name(stats, "i") +- self.assertEqual(fsa.ttot, 45) +- self.assertEqual(fsa.ncall, 3) +- self.assertEqual(fsa.nactualcall, 3) +- self.assertEqual(fsa.tsub, 3) +- self.assertEqual(fsa.children[fsb].ttot, fsb.ttot) +- self.assertEqual(fsa.children[fsb].tsub, fsb.tsub) +- self.assertEqual(fsb.children[fsc].ttot, fsc.ttot) +- self.assertEqual(fsb.children[fsc].tsub, fsc.tsub) +- self.assertEqual(fsc.tsub, 6) +- self.assertEqual(fsc.children[fsd].ttot, fsd.ttot) +- self.assertEqual(fsc.children[fsd].tsub, fsd.tsub) +- self.assertEqual(fsd.children[fse].ttot, fse.ttot) +- self.assertEqual(fsd.children[fse].tsub, fse.tsub) +- self.assertEqual(fse.children[fsf].ttot, fsf.ttot) +- self.assertEqual(fse.children[fsf].tsub, fsf.tsub) +- self.assertEqual(fsf.children[fsg].ttot, fsg.ttot) +- self.assertEqual(fsf.children[fsg].tsub, fsg.tsub) +- self.assertEqual(fsg.ttot, 18) +- self.assertEqual(fsg.tsub, 3) +- self.assertEqual(fsg.children[fsh].ttot, fsh.ttot) +- self.assertEqual(fsg.children[fsh].tsub, fsh.tsub) +- self.assertEqual(fsh.ttot, 15) +- self.assertEqual(fsh.tsub, 12) +- self.assertEqual(fsh.tavg, 5) +- self.assertEqual(fsh.children[fsi].ttot, fsi.ttot) +- self.assertEqual(fsh.children[fsi].tsub, fsi.tsub) +- #stats.debug_print() +- +- def test_merge_multithreaded_stats(self): +- 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("tests/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_multicontext"], 1) +- yappi.get_func_stats().save("tests/ystats2.ys") +- +- stats = yappi.YFuncStats([ +- "tests/ystats1.ys", +- "tests/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): +- 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("tests/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("tests/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("tests/ystats3.ys") +- self.assertRaises( +- yappi.YappiError, +- yappi.YFuncStats().add("tests/ystats1.ys").add, "tests/ystats3.ys" +- ) +- stats = yappi.YFuncStats(["tests/ystats1.ys", +- "tests/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 test_merge_aabab_aabbc(self): +- _timings = { +- "a_1": 15, +- "a_2": 14, +- "b_1": 12, +- "a_3": 10, +- "b_2": 9, +- "c_1": 4 +- } +- _yappi._set_test_timings(_timings) +- +- def a(): +- if self._ncall == 1: +- self._ncall += 1 +- a() +- elif self._ncall == 5: +- self._ncall += 1 +- a() +- else: +- b() +- +- def b(): +- if self._ncall == 2: +- self._ncall += 1 +- a() +- elif self._ncall == 6: +- self._ncall += 1 +- b() +- elif self._ncall == 7: +- c() +- else: +- return +- +- def c(): +- pass +- +- self._ncall = 1 +- stats = utils.run_and_get_func_stats(a, ) +- stats.save("tests/ystats1.ys") +- yappi.clear_stats() +- _yappi._set_test_timings(_timings) +- #stats.print_all() +- +- self._ncall = 5 +- stats = utils.run_and_get_func_stats(a, ) +- stats.save("tests/ystats2.ys") +- +- #stats.print_all() +- +- def a(): # same name but another function(code object) +- pass +- +- yappi.start() +- a() +- stats = yappi.get_func_stats().add( +- ["tests/ystats1.ys", "tests/ystats2.ys"] +- ) +- #stats.print_all() +- self.assertEqual(len(stats), 4) +- +- fsa = None +- for stat in stats: +- if stat.name == "a" and stat.ttot == 45: +- fsa = stat +- break +- self.assertTrue(fsa is not None) +- +- self.assertEqual(fsa.ncall, 7) +- self.assertEqual(fsa.nactualcall, 3) +- self.assertEqual(fsa.ttot, 45) +- self.assertEqual(fsa.tsub, 10) +- fsb = utils.find_stat_by_name(stats, "b") +- fsc = utils.find_stat_by_name(stats, "c") +- self.assertEqual(fsb.ncall, 6) +- self.assertEqual(fsb.nactualcall, 3) +- self.assertEqual(fsb.ttot, 36) +- self.assertEqual(fsb.tsub, 27) +- self.assertEqual(fsb.tavg, 6) +- self.assertEqual(fsc.ttot, 8) +- self.assertEqual(fsc.tsub, 8) +- self.assertEqual(fsc.tavg, 4) +- self.assertEqual(fsc.nactualcall, fsc.ncall, 2) +- +- +-class MultithreadedScenarios(utils.YappiUnitTestCase): +- +- def test_issue_32(self): +- ''' +- Start yappi from different thread and we get Internal Error(15) as +- the current_ctx_id() called while enumerating the threads in start() +- and as it does not swap to the enumerated ThreadState* the THreadState_GetDict() +- returns wrong object and thus sets an invalid id for the _ctx structure. +- +- When this issue happens multiple Threads have same tid as the internal ts_ptr +- will be same for different contexts. So, let's see if that happens +- ''' +- +- def foo(): +- time.sleep(0.2) +- +- def bar(): +- time.sleep(0.1) +- +- def thread_func(): +- yappi.set_clock_type("wall") +- yappi.start() +- +- bar() +- +- t = threading.Thread(target=thread_func) +- t.start() +- t.join() +- +- foo() +- +- yappi.stop() +- +- thread_ids = set() +- for tstat in yappi.get_thread_stats(): +- self.assertTrue(tstat.tid not in thread_ids) +- thread_ids.add(tstat.tid) +- +- def test_subsequent_profile(self): +- 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 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_ctx_stats(self): +- from threading import Thread +- DUMMY_WORKER_COUNT = 5 +- yappi.start() +- +- class DummyThread(Thread): +- pass +- +- def dummy(): +- pass +- +- def dummy_worker(): +- pass +- +- for i in range(DUMMY_WORKER_COUNT): +- t = DummyThread(target=dummy_worker) +- t.start() +- t.join() +- yappi.stop() +- stats = yappi.get_thread_stats() +- tsa = utils.find_stat_by_name(stats, "DummyThread") +- self.assertTrue(tsa is not None) +- yappi.clear_stats() +- time.sleep(1.0) +- _timings = { +- "a_1": 6, +- "b_1": 5, +- "c_1": 3, +- "d_1": 1, +- "a_2": 4, +- "b_2": 3, +- "c_2": 2, +- "d_2": 1 +- } +- _yappi._set_test_timings(_timings) +- +- class Thread1(Thread): +- pass +- +- class Thread2(Thread): +- pass +- +- def a(): +- b() +- +- def b(): +- c() +- +- def c(): +- d() +- +- def d(): +- time.sleep(0.6) +- +- yappi.set_clock_type("wall") +- yappi.start() +- t1 = Thread1(target=a) +- t1.start() +- t2 = Thread2(target=a) +- t2.start() +- t1.join() +- t2.join() +- stats = yappi.get_thread_stats() +- +- # the fist clear_stats clears the context table? +- tsa = utils.find_stat_by_name(stats, "DummyThread") +- self.assertTrue(tsa is None) +- +- tst1 = utils.find_stat_by_name(stats, "Thread1") +- tst2 = utils.find_stat_by_name(stats, "Thread2") +- tsmain = utils.find_stat_by_name(stats, "_MainThread") +- dummy() # call dummy to force ctx name to be retrieved again. +- self.assertTrue(len(stats) == 3) +- self.assertTrue(tst1 is not None) +- self.assertTrue(tst2 is not None) +- # TODO: I put dummy() to fix below, remove the comments after a while. +- self.assertTrue( # FIX: I see this fails sometimes +- tsmain is not None, +- 'Could not find "_MainThread". Found: %s' % (', '.join(utils.get_stat_names(stats)))) +- self.assertTrue(1.0 > tst2.ttot >= 0.5) +- self.assertTrue(1.0 > tst1.ttot >= 0.5) +- +- # test sorting of the ctx stats +- stats = stats.sort("totaltime", "desc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.ttot >= stat.ttot) +- prev_stat = stat +- stats = stats.sort("totaltime", "asc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.ttot <= stat.ttot) +- prev_stat = stat +- stats = stats.sort("schedcount", "desc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.sched_count >= stat.sched_count) +- prev_stat = stat +- stats = stats.sort("name", "desc") +- prev_stat = None +- for stat in stats: +- if prev_stat: +- self.assertTrue(prev_stat.name.lower() >= stat.name.lower()) +- prev_stat = stat +- self.assertRaises( +- yappi.YappiError, stats.sort, "invalid_thread_sorttype_arg" +- ) +- self.assertRaises( +- yappi.YappiError, stats.sort, "invalid_thread_sortorder_arg" +- ) +- +- def test_ctx_stats_cpu(self): +- +- def get_thread_name(): +- try: +- return threading.current_thread().name +- except AttributeError: +- return "Anonymous" +- +- def burn_cpu(sec): +- t0 = yappi.get_clock_time() +- elapsed = 0 +- while (elapsed < sec): +- for _ in range(1000): +- pass +- elapsed = yappi.get_clock_time() - t0 +- +- def test(): +- +- ts = [] +- for i in (0.01, 0.05, 0.1): +- t = threading.Thread(target=burn_cpu, args=(i, )) +- t.name = "burn_cpu-%s" % str(i) +- t.start() +- ts.append(t) +- for t in ts: +- t.join() +- +- yappi.set_clock_type("cpu") +- yappi.set_context_name_callback(get_thread_name) +- +- yappi.start() +- +- test() +- +- yappi.stop() +- +- tstats = yappi.get_thread_stats() +- r1 = ''' +- burn_cpu-0.1 3 123145356058624 0.100105 8 +- burn_cpu-0.05 2 123145361313792 0.050149 8 +- burn_cpu-0.01 1 123145356058624 0.010127 2 +- MainThread 0 4321620864 0.001632 6 +- ''' +- self.assert_ctx_stats_almost_equal(r1, tstats) +- +- def test_producer_consumer_with_queues(self): +- # we currently just stress yappi, no functionality test is done here. +- yappi.start() +- if utils.is_py3x(): +- from queue import Queue +- else: +- from Queue import Queue +- from threading import Thread +- WORKER_THREAD_COUNT = 50 +- WORK_ITEM_COUNT = 2000 +- +- def worker(): +- while True: +- item = q.get() +- # do the work with item +- q.task_done() +- +- q = Queue() +- for i in range(WORKER_THREAD_COUNT): +- t = Thread(target=worker) +- t.daemon = True +- t.start() +- +- for item in range(WORK_ITEM_COUNT): +- q.put(item) +- q.join() # block until all tasks are done +- #yappi.get_func_stats().sort("callcount").print_all() +- yappi.stop() +- +- def test_temporary_lock_waiting(self): +- yappi.start() +- _lock = threading.Lock() +- +- def worker(): +- _lock.acquire() +- try: +- time.sleep(1.0) +- finally: +- _lock.release() +- +- t1 = threading.Thread(target=worker) +- t2 = threading.Thread(target=worker) +- t1.start() +- t2.start() +- t1.join() +- t2.join() +- #yappi.get_func_stats().sort("callcount").print_all() +- yappi.stop() +- +- @unittest.skipIf(os.name != "posix", "requires Posix compliant OS") +- def test_signals_with_blocking_calls(self): +- import signal, os, time +- +- # just to verify if signal is handled correctly and stats/yappi are not corrupted. +- def handler(signum, frame): +- raise Exception("Signal handler executed!") +- +- yappi.start() +- signal.signal(signal.SIGALRM, handler) +- signal.alarm(1) +- self.assertRaises(Exception, time.sleep, 2) +- stats = yappi.get_func_stats() +- fsh = utils.find_stat_by_name(stats, "handler") +- self.assertTrue(fsh is not None) +- +- @unittest.skipIf(not sys.version_info >= (3, 2), "requires Python 3.2") +- def test_concurrent_futures(self): +- yappi.start() +- from concurrent.futures import ThreadPoolExecutor +- with ThreadPoolExecutor(max_workers=5) as executor: +- f = executor.submit(pow, 5, 2) +- self.assertEqual(f.result(), 25) +- time.sleep(1.0) +- yappi.stop() +- +- @unittest.skipIf(not sys.version_info >= (3, 2), "requires Python 3.2") +- def test_barrier(self): +- yappi.start() +- b = threading.Barrier(2, timeout=1) +- +- def worker(): +- try: +- b.wait() +- except threading.BrokenBarrierError: +- pass +- except Exception: +- raise Exception("BrokenBarrierError not raised") +- +- t1 = threading.Thread(target=worker) +- t1.start() +- #b.wait() +- t1.join() +- yappi.stop() +- +- +-class NonRecursiveFunctions(utils.YappiUnitTestCase): +- +- def test_abcd(self): +- _timings = {"a_1": 6, "b_1": 5, "c_1": 3, "d_1": 1} +- _yappi._set_test_timings(_timings) +- +- def a(): +- b() +- +- def b(): +- c() +- +- def c(): +- d() +- +- def d(): +- pass +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- fsc = utils.find_stat_by_name(stats, 'c') +- fsd = utils.find_stat_by_name(stats, 'd') +- cfsab = fsa.children[fsb] +- cfsbc = fsb.children[fsc] +- cfscd = fsc.children[fsd] +- +- self.assertEqual(fsa.ttot, 6) +- self.assertEqual(fsa.tsub, 1) +- self.assertEqual(fsb.ttot, 5) +- self.assertEqual(fsb.tsub, 2) +- self.assertEqual(fsc.ttot, 3) +- self.assertEqual(fsc.tsub, 2) +- self.assertEqual(fsd.ttot, 1) +- self.assertEqual(fsd.tsub, 1) +- self.assertEqual(cfsab.ttot, 5) +- self.assertEqual(cfsab.tsub, 2) +- self.assertEqual(cfsbc.ttot, 3) +- self.assertEqual(cfsbc.tsub, 2) +- self.assertEqual(cfscd.ttot, 1) +- self.assertEqual(cfscd.tsub, 1) +- +- def test_stop_in_middle(self): +- _timings = {"a_1": 6, "b_1": 4} +- _yappi._set_test_timings(_timings) +- +- def a(): +- b() +- yappi.stop() +- +- def b(): +- time.sleep(0.2) +- +- yappi.start() +- a() +- stats = yappi.get_func_stats() +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- +- self.assertEqual(fsa.ncall, 1) +- self.assertEqual(fsa.nactualcall, 0) +- self.assertEqual(fsa.ttot, 0) # no call_leave called +- self.assertEqual(fsa.tsub, 0) # no call_leave called +- self.assertEqual(fsb.ttot, 4) +- +- +-class RecursiveFunctions(utils.YappiUnitTestCase): +- +- def test_fibonacci(self): +- +- def fib(n): +- if n > 1: +- return fib(n - 1) + fib(n - 2) +- else: +- return n +- +- stats = utils.run_and_get_func_stats(fib, 22) +- fs = utils.find_stat_by_name(stats, 'fib') +- self.assertEqual(fs.ncall, 57313) +- self.assertEqual(fs.ttot, fs.tsub) +- +- def test_abcadc(self): +- _timings = { +- "a_1": 20, +- "b_1": 19, +- "c_1": 17, +- "a_2": 13, +- "d_1": 12, +- "c_2": 10, +- "a_3": 5 +- } +- _yappi._set_test_timings(_timings) +- +- def a(n): +- if n == 3: +- return +- if n == 1 + 1: +- d(n) +- else: +- b(n) +- +- def b(n): +- c(n) +- +- def c(n): +- a(n + 1) +- +- def d(n): +- c(n) +- +- stats = utils.run_and_get_func_stats(a, 1) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- fsc = utils.find_stat_by_name(stats, 'c') +- fsd = utils.find_stat_by_name(stats, 'd') +- self.assertEqual(fsa.ncall, 3) +- self.assertEqual(fsa.nactualcall, 1) +- self.assertEqual(fsa.ttot, 20) +- self.assertEqual(fsa.tsub, 7) +- self.assertEqual(fsb.ttot, 19) +- self.assertEqual(fsb.tsub, 2) +- self.assertEqual(fsc.ttot, 17) +- self.assertEqual(fsc.tsub, 9) +- self.assertEqual(fsd.ttot, 12) +- self.assertEqual(fsd.tsub, 2) +- cfsca = fsc.children[fsa] +- self.assertEqual(cfsca.nactualcall, 0) +- self.assertEqual(cfsca.ncall, 2) +- self.assertEqual(cfsca.ttot, 13) +- self.assertEqual(cfsca.tsub, 6) +- +- def test_aaaa(self): +- _timings = {"d_1": 9, "d_2": 7, "d_3": 3, "d_4": 2} +- _yappi._set_test_timings(_timings) +- +- def d(n): +- if n == 3: +- return +- d(n + 1) +- +- stats = utils.run_and_get_func_stats(d, 0) +- fsd = utils.find_stat_by_name(stats, 'd') +- self.assertEqual(fsd.ncall, 4) +- self.assertEqual(fsd.nactualcall, 1) +- self.assertEqual(fsd.ttot, 9) +- self.assertEqual(fsd.tsub, 9) +- cfsdd = fsd.children[fsd] +- self.assertEqual(cfsdd.ttot, 7) +- self.assertEqual(cfsdd.tsub, 7) +- self.assertEqual(cfsdd.ncall, 3) +- self.assertEqual(cfsdd.nactualcall, 0) +- +- def test_abcabc(self): +- _timings = { +- "a_1": 20, +- "b_1": 19, +- "c_1": 17, +- "a_2": 13, +- "b_2": 11, +- "c_2": 9, +- "a_3": 6 +- } +- _yappi._set_test_timings(_timings) +- +- def a(n): +- if n == 3: +- return +- else: +- b(n) +- +- def b(n): +- c(n) +- +- def c(n): +- a(n + 1) +- +- stats = utils.run_and_get_func_stats(a, 1) +- 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, 3) +- self.assertEqual(fsa.nactualcall, 1) +- self.assertEqual(fsa.ttot, 20) +- self.assertEqual(fsa.tsub, 9) +- self.assertEqual(fsb.ttot, 19) +- self.assertEqual(fsb.tsub, 4) +- self.assertEqual(fsc.ttot, 17) +- self.assertEqual(fsc.tsub, 7) +- cfsab = fsa.children[fsb] +- cfsbc = fsb.children[fsc] +- cfsca = fsc.children[fsa] +- self.assertEqual(cfsab.ttot, 19) +- self.assertEqual(cfsab.tsub, 4) +- self.assertEqual(cfsbc.ttot, 17) +- self.assertEqual(cfsbc.tsub, 7) +- self.assertEqual(cfsca.ttot, 13) +- self.assertEqual(cfsca.tsub, 8) +- +- def test_abcbca(self): +- _timings = {"a_1": 10, "b_1": 9, "c_1": 7, "b_2": 4, "c_2": 2, "a_2": 1} +- _yappi._set_test_timings(_timings) +- self._ncall = 1 +- +- def a(): +- if self._ncall == 1: +- b() +- else: +- return +- +- def b(): +- c() +- +- def c(): +- if self._ncall == 1: +- self._ncall += 1 +- b() +- else: +- a() +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- fsc = utils.find_stat_by_name(stats, 'c') +- cfsab = fsa.children[fsb] +- cfsbc = fsb.children[fsc] +- cfsca = fsc.children[fsa] +- self.assertEqual(fsa.ttot, 10) +- self.assertEqual(fsa.tsub, 2) +- self.assertEqual(fsb.ttot, 9) +- self.assertEqual(fsb.tsub, 4) +- self.assertEqual(fsc.ttot, 7) +- self.assertEqual(fsc.tsub, 4) +- self.assertEqual(cfsab.ttot, 9) +- self.assertEqual(cfsab.tsub, 2) +- self.assertEqual(cfsbc.ttot, 7) +- self.assertEqual(cfsbc.tsub, 4) +- self.assertEqual(cfsca.ttot, 1) +- self.assertEqual(cfsca.tsub, 1) +- self.assertEqual(cfsca.ncall, 1) +- self.assertEqual(cfsca.nactualcall, 0) +- +- def test_aabccb(self): +- _timings = { +- "a_1": 13, +- "a_2": 11, +- "b_1": 9, +- "c_1": 5, +- "c_2": 3, +- "b_2": 1 +- } +- _yappi._set_test_timings(_timings) +- self._ncall = 1 +- +- def a(): +- if self._ncall == 1: +- self._ncall += 1 +- a() +- else: +- b() +- +- def b(): +- if self._ncall == 3: +- return +- else: +- c() +- +- def c(): +- if self._ncall == 2: +- self._ncall += 1 +- c() +- else: +- b() +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- fsc = utils.find_stat_by_name(stats, 'c') +- cfsaa = fsa.children[fsa.index] +- cfsab = fsa.children[fsb] +- cfsbc = fsb.children[fsc.full_name] +- cfscc = fsc.children[fsc] +- cfscb = fsc.children[fsb] +- self.assertEqual(fsb.ttot, 9) +- self.assertEqual(fsb.tsub, 5) +- self.assertEqual(cfsbc.ttot, 5) +- self.assertEqual(cfsbc.tsub, 2) +- self.assertEqual(fsa.ttot, 13) +- self.assertEqual(fsa.tsub, 4) +- self.assertEqual(cfsab.ttot, 9) +- self.assertEqual(cfsab.tsub, 4) +- self.assertEqual(cfsaa.ttot, 11) +- self.assertEqual(cfsaa.tsub, 2) +- self.assertEqual(fsc.ttot, 5) +- self.assertEqual(fsc.tsub, 4) +- +- def test_abaa(self): +- _timings = {"a_1": 13, "b_1": 10, "a_2": 9, "a_3": 5} +- _yappi._set_test_timings(_timings) +- +- self._ncall = 1 +- +- def a(): +- if self._ncall == 1: +- b() +- elif self._ncall == 2: +- self._ncall += 1 +- a() +- else: +- return +- +- def b(): +- self._ncall += 1 +- a() +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- cfsaa = fsa.children[fsa] +- cfsba = fsb.children[fsa] +- self.assertEqual(fsb.ttot, 10) +- self.assertEqual(fsb.tsub, 1) +- self.assertEqual(fsa.ttot, 13) +- self.assertEqual(fsa.tsub, 12) +- self.assertEqual(cfsaa.ttot, 5) +- self.assertEqual(cfsaa.tsub, 5) +- self.assertEqual(cfsba.ttot, 9) +- self.assertEqual(cfsba.tsub, 4) +- +- def test_aabb(self): +- _timings = {"a_1": 13, "a_2": 10, "b_1": 9, "b_2": 5} +- _yappi._set_test_timings(_timings) +- +- self._ncall = 1 +- +- def a(): +- if self._ncall == 1: +- self._ncall += 1 +- a() +- elif self._ncall == 2: +- b() +- else: +- return +- +- def b(): +- if self._ncall == 2: +- self._ncall += 1 +- b() +- else: +- return +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- cfsaa = fsa.children[fsa] +- cfsab = fsa.children[fsb] +- cfsbb = fsb.children[fsb] +- self.assertEqual(fsa.ttot, 13) +- self.assertEqual(fsa.tsub, 4) +- self.assertEqual(fsb.ttot, 9) +- self.assertEqual(fsb.tsub, 9) +- self.assertEqual(cfsaa.ttot, 10) +- self.assertEqual(cfsaa.tsub, 1) +- self.assertEqual(cfsab.ttot, 9) +- self.assertEqual(cfsab.tsub, 4) +- self.assertEqual(cfsbb.ttot, 5) +- self.assertEqual(cfsbb.tsub, 5) +- +- def test_abbb(self): +- _timings = {"a_1": 13, "b_1": 10, "b_2": 6, "b_3": 1} +- _yappi._set_test_timings(_timings) +- +- self._ncall = 1 +- +- def a(): +- if self._ncall == 1: +- b() +- +- def b(): +- if self._ncall == 3: +- return +- self._ncall += 1 +- b() +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- cfsab = fsa.children[fsb] +- cfsbb = fsb.children[fsb] +- self.assertEqual(fsa.ttot, 13) +- self.assertEqual(fsa.tsub, 3) +- self.assertEqual(fsb.ttot, 10) +- self.assertEqual(fsb.tsub, 10) +- self.assertEqual(fsb.ncall, 3) +- self.assertEqual(fsb.nactualcall, 1) +- self.assertEqual(cfsab.ttot, 10) +- self.assertEqual(cfsab.tsub, 4) +- self.assertEqual(cfsbb.ttot, 6) +- self.assertEqual(cfsbb.tsub, 6) +- self.assertEqual(cfsbb.nactualcall, 0) +- self.assertEqual(cfsbb.ncall, 2) +- +- def test_aaab(self): +- _timings = {"a_1": 13, "a_2": 10, "a_3": 6, "b_1": 1} +- _yappi._set_test_timings(_timings) +- +- self._ncall = 1 +- +- def a(): +- if self._ncall == 3: +- b() +- return +- self._ncall += 1 +- a() +- +- def b(): +- return +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- cfsaa = fsa.children[fsa] +- cfsab = fsa.children[fsb] +- self.assertEqual(fsa.ttot, 13) +- self.assertEqual(fsa.tsub, 12) +- self.assertEqual(fsb.ttot, 1) +- self.assertEqual(fsb.tsub, 1) +- self.assertEqual(cfsaa.ttot, 10) +- self.assertEqual(cfsaa.tsub, 9) +- self.assertEqual(cfsab.ttot, 1) +- self.assertEqual(cfsab.tsub, 1) +- +- def test_abab(self): +- _timings = {"a_1": 13, "b_1": 10, "a_2": 6, "b_2": 1} +- _yappi._set_test_timings(_timings) +- +- self._ncall = 1 +- +- def a(): +- b() +- +- def b(): +- if self._ncall == 2: +- return +- self._ncall += 1 +- a() +- +- stats = utils.run_and_get_func_stats(a) +- fsa = utils.find_stat_by_name(stats, 'a') +- fsb = utils.find_stat_by_name(stats, 'b') +- cfsab = fsa.children[fsb] +- cfsba = fsb.children[fsa] +- self.assertEqual(fsa.ttot, 13) +- self.assertEqual(fsa.tsub, 8) +- self.assertEqual(fsb.ttot, 10) +- self.assertEqual(fsb.tsub, 5) +- self.assertEqual(cfsab.ttot, 10) +- self.assertEqual(cfsab.tsub, 5) +- self.assertEqual(cfsab.ncall, 2) +- self.assertEqual(cfsab.nactualcall, 1) +- self.assertEqual(cfsba.ttot, 6) +- self.assertEqual(cfsba.tsub, 5) +- +- +-if __name__ == '__main__': +- # import sys;sys.argv = ['', 'BasicUsage.test_run_as_script'] +- # import sys;sys.argv = ['', 'MultithreadedScenarios.test_subsequent_profile'] +- unittest.main() ++import os ++import sys ++import time ++import threading ++import unittest ++import yappi ++import _yappi ++import tests.utils as utils ++import multiprocessing # added to fix http://bugs.python.org/issue15881 for > Py2.6 ++import subprocess ++ ++_counter = 0 ++ ++ ++class BasicUsage(utils.YappiUnitTestCase): ++ ++ def test_callback_function_int_return_overflow(self): ++ # this test is just here to check if any errors are generated, as the err ++ # is printed in C side, I did not include it here. THere are ways to test ++ # this deterministically, I did not bother ++ import ctypes ++ ++ def _unsigned_overflow_margin(): ++ return 2**(ctypes.sizeof(ctypes.c_void_p) * 8) - 1 ++ ++ def foo(): ++ pass ++ ++ #with utils.captured_output() as (out, err): ++ yappi.set_context_id_callback(_unsigned_overflow_margin) ++ yappi.set_tag_callback(_unsigned_overflow_margin) ++ yappi.start() ++ foo() ++ ++ def test_issue60(self): ++ ++ def foo(): ++ buf = bytearray() ++ buf += b't' * 200 ++ view = memoryview(buf)[10:] ++ view = view.tobytes() ++ del buf[:10] # this throws exception ++ return view ++ ++ yappi.start(builtins=True) ++ foo() ++ self.assertTrue( ++ len( ++ yappi.get_func_stats( ++ filter_callback=lambda x: yappi. ++ func_matches(x, [memoryview.tobytes]) ++ ) ++ ) > 0 ++ ) ++ yappi.stop() ++ ++ def test_issue54(self): ++ ++ def _tag_cbk(): ++ global _counter ++ _counter += 1 ++ return _counter ++ ++ def a(): ++ pass ++ ++ def b(): ++ pass ++ ++ yappi.set_tag_callback(_tag_cbk) ++ yappi.start() ++ a() ++ a() ++ a() ++ yappi.stop() ++ stats = yappi.get_func_stats() ++ self.assertEqual(stats.pop().ncall, 3) # aggregated if no tag is given ++ stats = yappi.get_func_stats(tag=1) ++ ++ for i in range(1, 3): ++ stats = yappi.get_func_stats(tag=i) ++ stats = yappi.get_func_stats( ++ tag=i, filter_callback=lambda x: yappi.func_matches(x, [a]) ++ ) ++ ++ stat = stats.pop() ++ self.assertEqual(stat.ncall, 1) ++ ++ yappi.set_tag_callback(None) ++ yappi.clear_stats() ++ yappi.start() ++ b() ++ b() ++ stats = yappi.get_func_stats() ++ self.assertEqual(len(stats), 1) ++ stat = stats.pop() ++ self.assertEqual(stat.ncall, 2) ++ ++ def test_filter(self): ++ ++ def a(): ++ pass ++ ++ def b(): ++ a() ++ ++ def c(): ++ b() ++ ++ _TCOUNT = 5 ++ ++ ts = [] ++ yappi.start() ++ for i in range(_TCOUNT): ++ t = threading.Thread(target=c) ++ t.start() ++ ts.append(t) ++ ++ for t in ts: ++ t.join() ++ ++ yappi.stop() ++ ++ ctx_ids = [] ++ for tstat in yappi.get_thread_stats(): ++ if tstat.name == '_MainThread': ++ main_ctx_id = tstat.id ++ else: ++ ctx_ids.append(tstat.id) ++ ++ fstats = yappi.get_func_stats(filter={"ctx_id": 9}) ++ self.assertTrue(fstats.empty()) ++ fstats = yappi.get_func_stats( ++ filter={ ++ "ctx_id": main_ctx_id, ++ "name": "c" ++ } ++ ) # main thread ++ self.assertTrue(fstats.empty()) ++ ++ for i in ctx_ids: ++ fstats = yappi.get_func_stats( ++ filter={ ++ "ctx_id": i, ++ "name": "a", ++ "ncall": 1 ++ } ++ ) ++ self.assertEqual(fstats.pop().ncall, 1) ++ fstats = yappi.get_func_stats(filter={"ctx_id": i, "name": "b"}) ++ self.assertEqual(fstats.pop().ncall, 1) ++ fstats = yappi.get_func_stats(filter={"ctx_id": i, "name": "c"}) ++ self.assertEqual(fstats.pop().ncall, 1) ++ ++ yappi.clear_stats() ++ yappi.start(builtins=True) ++ time.sleep(0.1) ++ yappi.stop() ++ fstats = yappi.get_func_stats(filter={"module": "time"}) ++ self.assertEqual(len(fstats), 1) ++ ++ # invalid filters` ++ self.assertRaises( ++ Exception, yappi.get_func_stats, filter={'tag': "sss"} ++ ) ++ self.assertRaises( ++ Exception, yappi.get_func_stats, filter={'ctx_id': "None"} ++ ) ++ ++ def test_filter_callback(self): ++ ++ def a(): ++ time.sleep(0.1) ++ ++ def b(): ++ a() ++ ++ def c(): ++ pass ++ ++ def d(): ++ pass ++ ++ yappi.set_clock_type("wall") ++ yappi.start(builtins=True) ++ a() ++ b() ++ c() ++ d() ++ stats = yappi.get_func_stats( ++ filter_callback=lambda x: yappi.func_matches(x, [a, b]) ++ ) ++ #stats.print_all() ++ r1 = ''' ++ tests/test_functionality.py:98 a 2 0.000000 0.200350 0.100175 ++ tests/test_functionality.py:101 b 1 0.000000 0.120000 0.100197 ++ ''' ++ self.assert_traces_almost_equal(r1, stats) ++ self.assertEqual(len(stats), 2) ++ stats = yappi.get_func_stats( ++ filter_callback=lambda x: yappi. ++ module_matches(x, [sys.modules[__name__]]) ++ ) ++ r1 = ''' ++ tests/test_functionality.py:98 a 2 0.000000 0.230130 0.115065 ++ tests/test_functionality.py:101 b 1 0.000000 0.120000 0.109011 ++ tests/test_functionality.py:104 c 1 0.000000 0.000002 0.000002 ++ tests/test_functionality.py:107 d 1 0.000000 0.000001 0.000001 ++ ''' ++ self.assert_traces_almost_equal(r1, stats) ++ self.assertEqual(len(stats), 4) ++ ++ stats = yappi.get_func_stats( ++ filter_callback=lambda x: yappi.func_matches(x, [time.sleep]) ++ ) ++ self.assertEqual(len(stats), 1) ++ r1 = ''' ++ time.sleep 2 0.206804 0.220000 0.103402 ++ ''' ++ self.assert_traces_almost_equal(r1, stats) ++ ++ 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_get_clock(self): ++ yappi.set_clock_type('cpu') ++ self.assertEqual('cpu', yappi.get_clock_type()) ++ clock_info = yappi.get_clock_info() ++ self.assertTrue('api' in clock_info) ++ self.assertTrue('resolution' in clock_info) ++ ++ yappi.set_clock_type('wall') ++ self.assertEqual('wall', yappi.get_clock_type()) ++ ++ t0 = yappi.get_clock_time() ++ time.sleep(0.1) ++ duration = yappi.get_clock_time() - t0 ++ self.assertTrue(0.05 < duration < 0.3) ++ ++ def test_profile_decorator(self): ++ ++ def aggregate(func, stats): ++ fname = "tests/%s.profile" % (func.__name__) ++ try: ++ stats.add(fname) ++ except IOError: ++ pass ++ stats.save(fname) ++ raise Exception("messing around") ++ ++ @yappi.profile(return_callback=aggregate) ++ def a(x, y): ++ if x + y == 25: ++ raise Exception("") ++ return x + y ++ ++ def b(): ++ pass ++ ++ try: ++ os.remove( ++ "tests/a.profile" ++ ) # remove the one from prev test, if available ++ except: ++ pass ++ ++ # global profile is on to mess things up ++ yappi.start() ++ b() ++ ++ # assert functionality and call function at same time ++ try: ++ self.assertEqual(a(1, 2), 3) ++ except: ++ pass ++ try: ++ self.assertEqual(a(2, 5), 7) ++ except: ++ pass ++ try: ++ a(4, 21) ++ except: ++ pass ++ stats = yappi.get_func_stats().add("tests/a.profile") ++ fsa = utils.find_stat_by_name(stats, 'a') ++ self.assertEqual(fsa.ncall, 3) ++ self.assertEqual(len(stats), 1) # b() should be cleared out. ++ ++ @yappi.profile(return_callback=aggregate) ++ def count_down_rec(n): ++ if n == 0: ++ return ++ count_down_rec(n - 1) ++ ++ try: ++ os.remove( ++ "tests/count_down_rec.profile" ++ ) # remove the one from prev test, if available ++ except: ++ pass ++ ++ try: ++ count_down_rec(4) ++ except: ++ pass ++ try: ++ count_down_rec(3) ++ except: ++ pass ++ ++ stats = yappi.YFuncStats("tests/count_down_rec.profile") ++ fsrec = utils.find_stat_by_name(stats, 'count_down_rec') ++ self.assertEqual(fsrec.ncall, 9) ++ self.assertEqual(fsrec.nactualcall, 2) ++ ++ def test_strip_dirs(self): ++ ++ def a(): ++ pass ++ ++ stats = utils.run_and_get_func_stats(a, ) ++ stats.strip_dirs() ++ fsa = utils.find_stat_by_name(stats, "a") ++ self.assertEqual(fsa.module, os.path.basename(fsa.module)) ++ ++ @unittest.skipIf(os.name == "nt", "do not run on Windows") ++ def test_run_as_script(self): ++ import re ++ p = subprocess.Popen( ++ ['yappi', os.path.join('./tests', 'run_as_script.py')], ++ stdout=subprocess.PIPE ++ ) ++ out, err = p.communicate() ++ self.assertEqual(p.returncode, 0) ++ func_stats, thread_stats = re.split( ++ b'name\\s+id\\s+tid\\s+ttot\\s+scnt\\s*\n', out ++ ) ++ self.assertTrue(b'FancyThread' in thread_stats) ++ ++ def test_yappi_overhead(self): ++ LOOP_COUNT = 100000 ++ ++ def a(): ++ pass ++ ++ def b(): ++ for i in range(LOOP_COUNT): ++ a() ++ ++ t0 = time.time() ++ yappi.start() ++ b() ++ yappi.stop() ++ time_with_yappi = time.time() - t0 ++ t0 = time.time() ++ b() ++ time_without_yappi = time.time() - t0 ++ if time_without_yappi == 0: ++ time_without_yappi = 0.000001 ++ ++ # in latest v0.82, I calculated this as close to "7.0" in my machine. ++ # however, %83 of this overhead is coming from tickcount(). The other %17 ++ # seems to have been evenly distributed to the internal bookkeeping ++ # structures/algorithms which seems acceptable. Note that our test only ++ # tests one function being profiled at-a-time in a short interval. ++ # profiling high number of functions in a small time ++ # is a different beast, (which is pretty unlikely in most applications) ++ # So as a conclusion: I cannot see any optimization window for Yappi that ++ # is worth implementing as we will only optimize %17 of the time. ++ sys.stderr.write("\r\nYappi puts %0.1f times overhead to the profiled application in average.\r\n" % \ ++ (time_with_yappi / time_without_yappi)) ++ ++ 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 test_generator(self): ++ ++ def _gen(n): ++ while (n > 0): ++ yield n ++ n -= 1 ++ ++ yappi.start() ++ for x in _gen(5): ++ pass ++ self.assertTrue( ++ yappi.convert2pstats(yappi.get_func_stats()) is not None ++ ) ++ ++ def test_slice_child_stats_and_strip_dirs(self): ++ ++ def b(): ++ for i in range(10000000): ++ pass ++ ++ def a(): ++ b() ++ ++ yappi.start(builtins=True) ++ a() ++ stats = yappi.get_func_stats() ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ self.assertTrue(fsa.children[0:1] is not None) ++ prev_afullname = fsa.full_name ++ prev_bchildfullname = fsa.children[fsb].full_name ++ stats.strip_dirs() ++ self.assertTrue(len(prev_afullname) > len(fsa.full_name)) ++ self.assertTrue( ++ len(prev_bchildfullname) > len(fsa.children[fsb].full_name) ++ ) ++ ++ def test_children_stat_functions(self): ++ _timings = {"a_1": 5, "b_1": 3, "c_1": 1} ++ _yappi._set_test_timings(_timings) ++ ++ def b(): ++ pass ++ ++ def c(): ++ pass ++ ++ def a(): ++ b() ++ c() ++ ++ yappi.start() ++ a() ++ b() # non-child call ++ c() # non-child call ++ stats = yappi.get_func_stats() ++ fsa = utils.find_stat_by_name(stats, 'a') ++ childs_of_a = fsa.children.get().sort("tavg", "desc") ++ prev_item = None ++ for item in childs_of_a: ++ if prev_item: ++ self.assertTrue(prev_item.tavg > item.tavg) ++ prev_item = item ++ childs_of_a.sort("name", "desc") ++ prev_item = None ++ for item in childs_of_a: ++ if prev_item: ++ self.assertTrue(prev_item.name > item.name) ++ prev_item = item ++ childs_of_a.clear() ++ self.assertTrue(childs_of_a.empty()) ++ ++ def test_no_stats_different_clock_type_load(self): ++ ++ def a(): ++ pass ++ ++ yappi.start() ++ a() ++ yappi.stop() ++ yappi.get_func_stats().save("tests/ystats1.ys") ++ yappi.clear_stats() ++ yappi.set_clock_type("WALL") ++ yappi.start() ++ yappi.stop() ++ stats = yappi.get_func_stats().add("tests/ystats1.ys") ++ fsa = utils.find_stat_by_name(stats, 'a') ++ self.assertTrue(fsa is not None) ++ ++ def test_subsequent_profile(self): ++ _timings = {"a_1": 1, "b_1": 1} ++ _yappi._set_test_timings(_timings) ++ ++ def a(): ++ pass ++ ++ def b(): ++ pass ++ ++ yappi.start() ++ a() ++ yappi.stop() ++ yappi.start() ++ b() ++ yappi.stop() ++ stats = yappi.get_func_stats() ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ self.assertTrue(fsa is not None) ++ self.assertTrue(fsb is not None) ++ self.assertEqual(fsa.ttot, 1) ++ self.assertEqual(fsb.ttot, 1) ++ ++ def test_lambda(self): ++ f = lambda: time.sleep(0.3) ++ yappi.set_clock_type("wall") ++ yappi.start() ++ f() ++ stats = yappi.get_func_stats() ++ fsa = utils.find_stat_by_name(stats, '') ++ self.assertTrue(fsa.ttot > 0.1) ++ ++ 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_stat_sorting(self): ++ _timings = {"a_1": 13, "b_1": 10, "a_2": 6, "b_2": 1} ++ _yappi._set_test_timings(_timings) ++ ++ self._ncall = 1 ++ ++ def a(): ++ b() ++ ++ def b(): ++ if self._ncall == 2: ++ return ++ self._ncall += 1 ++ a() ++ ++ stats = utils.run_and_get_func_stats(a) ++ stats = stats.sort("totaltime", "desc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.ttot >= stat.ttot) ++ prev_stat = stat ++ stats = stats.sort("totaltime", "asc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.ttot <= stat.ttot) ++ prev_stat = stat ++ stats = stats.sort("avgtime", "asc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.tavg <= stat.tavg) ++ prev_stat = stat ++ stats = stats.sort("name", "asc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.name <= stat.name) ++ prev_stat = stat ++ stats = stats.sort("subtime", "asc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.tsub <= stat.tsub) ++ prev_stat = stat ++ ++ self.assertRaises( ++ yappi.YappiError, stats.sort, "invalid_func_sorttype_arg" ++ ) ++ self.assertRaises( ++ yappi.YappiError, stats.sort, "totaltime", ++ "invalid_func_sortorder_arg" ++ ) ++ ++ 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_multicontext"], 1) ++ self.assertEqual(len(yappi.get_thread_stats()), 1) ++ ++ 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_singlethread_profiling(self): ++ 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(profile_threads=False) ++ ++ 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 None) ++ self.assertTrue(fsa2 is not None) ++ self.assertTrue(fsa2.ttot > 0.1) ++ ++ 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 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')) ++ ++ ++class StatSaveScenarios(utils.YappiUnitTestCase): ++ ++ 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("tests/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("tests/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("tests/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("tests/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( ++ 'tests/a1.pstats', 'tests/a2.pstats', 'tests/b1.pstats', ++ 'tests/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) ++ ++ def test_merge_stats(self): ++ _timings = { ++ "a_1": 15, ++ "b_1": 14, ++ "c_1": 12, ++ "d_1": 10, ++ "e_1": 9, ++ "f_1": 7, ++ "g_1": 6, ++ "h_1": 5, ++ "i_1": 1 ++ } ++ _yappi._set_test_timings(_timings) ++ ++ def a(): ++ b() ++ ++ def b(): ++ c() ++ ++ def c(): ++ d() ++ ++ def d(): ++ e() ++ ++ def e(): ++ f() ++ ++ def f(): ++ g() ++ ++ def g(): ++ h() ++ ++ def h(): ++ i() ++ ++ def i(): ++ pass ++ ++ yappi.start() ++ a() ++ a() ++ yappi.stop() ++ stats = yappi.get_func_stats() ++ self.assertRaises( ++ NotImplementedError, stats.save, "", "INVALID_SAVE_TYPE" ++ ) ++ stats.save("tests/ystats2.ys") ++ yappi.clear_stats() ++ _yappi._set_test_timings(_timings) ++ yappi.start() ++ a() ++ stats = yappi.get_func_stats().add("tests/ystats2.ys") ++ fsa = utils.find_stat_by_name(stats, "a") ++ fsb = utils.find_stat_by_name(stats, "b") ++ fsc = utils.find_stat_by_name(stats, "c") ++ fsd = utils.find_stat_by_name(stats, "d") ++ fse = utils.find_stat_by_name(stats, "e") ++ fsf = utils.find_stat_by_name(stats, "f") ++ fsg = utils.find_stat_by_name(stats, "g") ++ fsh = utils.find_stat_by_name(stats, "h") ++ fsi = utils.find_stat_by_name(stats, "i") ++ self.assertEqual(fsa.ttot, 45) ++ self.assertEqual(fsa.ncall, 3) ++ self.assertEqual(fsa.nactualcall, 3) ++ self.assertEqual(fsa.tsub, 3) ++ self.assertEqual(fsa.children[fsb].ttot, fsb.ttot) ++ self.assertEqual(fsa.children[fsb].tsub, fsb.tsub) ++ self.assertEqual(fsb.children[fsc].ttot, fsc.ttot) ++ self.assertEqual(fsb.children[fsc].tsub, fsc.tsub) ++ self.assertEqual(fsc.tsub, 6) ++ self.assertEqual(fsc.children[fsd].ttot, fsd.ttot) ++ self.assertEqual(fsc.children[fsd].tsub, fsd.tsub) ++ self.assertEqual(fsd.children[fse].ttot, fse.ttot) ++ self.assertEqual(fsd.children[fse].tsub, fse.tsub) ++ self.assertEqual(fse.children[fsf].ttot, fsf.ttot) ++ self.assertEqual(fse.children[fsf].tsub, fsf.tsub) ++ self.assertEqual(fsf.children[fsg].ttot, fsg.ttot) ++ self.assertEqual(fsf.children[fsg].tsub, fsg.tsub) ++ self.assertEqual(fsg.ttot, 18) ++ self.assertEqual(fsg.tsub, 3) ++ self.assertEqual(fsg.children[fsh].ttot, fsh.ttot) ++ self.assertEqual(fsg.children[fsh].tsub, fsh.tsub) ++ self.assertEqual(fsh.ttot, 15) ++ self.assertEqual(fsh.tsub, 12) ++ self.assertEqual(fsh.tavg, 5) ++ self.assertEqual(fsh.children[fsi].ttot, fsi.ttot) ++ self.assertEqual(fsh.children[fsi].tsub, fsi.tsub) ++ #stats.debug_print() ++ ++ def test_merge_multithreaded_stats(self): ++ 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("tests/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_multicontext"], 1) ++ yappi.get_func_stats().save("tests/ystats2.ys") ++ ++ stats = yappi.YFuncStats([ ++ "tests/ystats1.ys", ++ "tests/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): ++ 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("tests/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("tests/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("tests/ystats3.ys") ++ self.assertRaises( ++ yappi.YappiError, ++ yappi.YFuncStats().add("tests/ystats1.ys").add, "tests/ystats3.ys" ++ ) ++ stats = yappi.YFuncStats(["tests/ystats1.ys", ++ "tests/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 test_merge_aabab_aabbc(self): ++ _timings = { ++ "a_1": 15, ++ "a_2": 14, ++ "b_1": 12, ++ "a_3": 10, ++ "b_2": 9, ++ "c_1": 4 ++ } ++ _yappi._set_test_timings(_timings) ++ ++ def a(): ++ if self._ncall == 1: ++ self._ncall += 1 ++ a() ++ elif self._ncall == 5: ++ self._ncall += 1 ++ a() ++ else: ++ b() ++ ++ def b(): ++ if self._ncall == 2: ++ self._ncall += 1 ++ a() ++ elif self._ncall == 6: ++ self._ncall += 1 ++ b() ++ elif self._ncall == 7: ++ c() ++ else: ++ return ++ ++ def c(): ++ pass ++ ++ self._ncall = 1 ++ stats = utils.run_and_get_func_stats(a, ) ++ stats.save("tests/ystats1.ys") ++ yappi.clear_stats() ++ _yappi._set_test_timings(_timings) ++ #stats.print_all() ++ ++ self._ncall = 5 ++ stats = utils.run_and_get_func_stats(a, ) ++ stats.save("tests/ystats2.ys") ++ ++ #stats.print_all() ++ ++ def a(): # same name but another function(code object) ++ pass ++ ++ yappi.start() ++ a() ++ stats = yappi.get_func_stats().add( ++ ["tests/ystats1.ys", "tests/ystats2.ys"] ++ ) ++ #stats.print_all() ++ self.assertEqual(len(stats), 4) ++ ++ fsa = None ++ for stat in stats: ++ if stat.name == "a" and stat.ttot == 45: ++ fsa = stat ++ break ++ self.assertTrue(fsa is not None) ++ ++ self.assertEqual(fsa.ncall, 7) ++ self.assertEqual(fsa.nactualcall, 3) ++ self.assertEqual(fsa.ttot, 45) ++ self.assertEqual(fsa.tsub, 10) ++ fsb = utils.find_stat_by_name(stats, "b") ++ fsc = utils.find_stat_by_name(stats, "c") ++ self.assertEqual(fsb.ncall, 6) ++ self.assertEqual(fsb.nactualcall, 3) ++ self.assertEqual(fsb.ttot, 36) ++ self.assertEqual(fsb.tsub, 27) ++ self.assertEqual(fsb.tavg, 6) ++ self.assertEqual(fsc.ttot, 8) ++ self.assertEqual(fsc.tsub, 8) ++ self.assertEqual(fsc.tavg, 4) ++ self.assertEqual(fsc.nactualcall, fsc.ncall, 2) ++ ++ ++class MultithreadedScenarios(utils.YappiUnitTestCase): ++ ++ def test_issue_32(self): ++ ''' ++ Start yappi from different thread and we get Internal Error(15) as ++ the current_ctx_id() called while enumerating the threads in start() ++ and as it does not swap to the enumerated ThreadState* the THreadState_GetDict() ++ returns wrong object and thus sets an invalid id for the _ctx structure. ++ ++ When this issue happens multiple Threads have same tid as the internal ts_ptr ++ will be same for different contexts. So, let's see if that happens ++ ''' ++ ++ def foo(): ++ time.sleep(0.2) ++ ++ def bar(): ++ time.sleep(0.1) ++ ++ def thread_func(): ++ yappi.set_clock_type("wall") ++ yappi.start() ++ ++ bar() ++ ++ t = threading.Thread(target=thread_func) ++ t.start() ++ t.join() ++ ++ foo() ++ ++ yappi.stop() ++ ++ thread_ids = set() ++ for tstat in yappi.get_thread_stats(): ++ self.assertTrue(tstat.tid not in thread_ids) ++ thread_ids.add(tstat.tid) ++ ++ def test_subsequent_profile(self): ++ 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 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_ctx_stats(self): ++ from threading import Thread ++ DUMMY_WORKER_COUNT = 5 ++ yappi.start() ++ ++ class DummyThread(Thread): ++ pass ++ ++ def dummy(): ++ pass ++ ++ def dummy_worker(): ++ pass ++ ++ for i in range(DUMMY_WORKER_COUNT): ++ t = DummyThread(target=dummy_worker) ++ t.start() ++ t.join() ++ yappi.stop() ++ stats = yappi.get_thread_stats() ++ tsa = utils.find_stat_by_name(stats, "DummyThread") ++ self.assertTrue(tsa is not None) ++ yappi.clear_stats() ++ time.sleep(1.0) ++ _timings = { ++ "a_1": 6, ++ "b_1": 5, ++ "c_1": 3, ++ "d_1": 1, ++ "a_2": 4, ++ "b_2": 3, ++ "c_2": 2, ++ "d_2": 1 ++ } ++ _yappi._set_test_timings(_timings) ++ ++ class Thread1(Thread): ++ pass ++ ++ class Thread2(Thread): ++ pass ++ ++ def a(): ++ b() ++ ++ def b(): ++ c() ++ ++ def c(): ++ d() ++ ++ def d(): ++ time.sleep(0.6) ++ ++ yappi.set_clock_type("wall") ++ yappi.start() ++ t1 = Thread1(target=a) ++ t1.start() ++ t2 = Thread2(target=a) ++ t2.start() ++ t1.join() ++ t2.join() ++ stats = yappi.get_thread_stats() ++ ++ # the fist clear_stats clears the context table? ++ tsa = utils.find_stat_by_name(stats, "DummyThread") ++ self.assertTrue(tsa is None) ++ ++ tst1 = utils.find_stat_by_name(stats, "Thread1") ++ tst2 = utils.find_stat_by_name(stats, "Thread2") ++ tsmain = utils.find_stat_by_name(stats, "_MainThread") ++ dummy() # call dummy to force ctx name to be retrieved again. ++ self.assertTrue(len(stats) == 3) ++ self.assertTrue(tst1 is not None) ++ self.assertTrue(tst2 is not None) ++ # TODO: I put dummy() to fix below, remove the comments after a while. ++ self.assertTrue( # FIX: I see this fails sometimes ++ tsmain is not None, ++ 'Could not find "_MainThread". Found: %s' % (', '.join(utils.get_stat_names(stats)))) ++ self.assertTrue(1.0 > tst2.ttot >= 0.5) ++ self.assertTrue(1.0 > tst1.ttot >= 0.5) ++ ++ # test sorting of the ctx stats ++ stats = stats.sort("totaltime", "desc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.ttot >= stat.ttot) ++ prev_stat = stat ++ stats = stats.sort("totaltime", "asc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.ttot <= stat.ttot) ++ prev_stat = stat ++ stats = stats.sort("schedcount", "desc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.sched_count >= stat.sched_count) ++ prev_stat = stat ++ stats = stats.sort("name", "desc") ++ prev_stat = None ++ for stat in stats: ++ if prev_stat: ++ self.assertTrue(prev_stat.name.lower() >= stat.name.lower()) ++ prev_stat = stat ++ self.assertRaises( ++ yappi.YappiError, stats.sort, "invalid_thread_sorttype_arg" ++ ) ++ self.assertRaises( ++ yappi.YappiError, stats.sort, "invalid_thread_sortorder_arg" ++ ) ++ ++ def test_ctx_stats_cpu(self): ++ ++ def get_thread_name(): ++ try: ++ return threading.current_thread().name ++ except AttributeError: ++ return "Anonymous" ++ ++ def burn_cpu(sec): ++ t0 = yappi.get_clock_time() ++ elapsed = 0 ++ while (elapsed < sec): ++ for _ in range(1000): ++ pass ++ elapsed = yappi.get_clock_time() - t0 ++ ++ def test(): ++ ++ ts = [] ++ for i in (0.01, 0.05, 0.1): ++ t = threading.Thread(target=burn_cpu, args=(i, )) ++ t.name = "burn_cpu-%s" % str(i) ++ t.start() ++ ts.append(t) ++ for t in ts: ++ t.join() ++ ++ yappi.set_clock_type("cpu") ++ yappi.set_context_name_callback(get_thread_name) ++ ++ yappi.start() ++ ++ test() ++ ++ yappi.stop() ++ ++ tstats = yappi.get_thread_stats() ++ r1 = ''' ++ burn_cpu-0.1 3 123145356058624 0.100105 8 ++ burn_cpu-0.05 2 123145361313792 0.050149 8 ++ burn_cpu-0.01 1 123145356058624 0.010127 2 ++ MainThread 0 4321620864 0.001632 6 ++ ''' ++ self.assert_ctx_stats_almost_equal(r1, tstats) ++ ++ def test_producer_consumer_with_queues(self): ++ # we currently just stress yappi, no functionality test is done here. ++ yappi.start() ++ if utils.is_py3x(): ++ from queue import Queue ++ else: ++ from Queue import Queue ++ from threading import Thread ++ WORKER_THREAD_COUNT = 50 ++ WORK_ITEM_COUNT = 2000 ++ ++ def worker(): ++ while True: ++ item = q.get() ++ # do the work with item ++ q.task_done() ++ ++ q = Queue() ++ for i in range(WORKER_THREAD_COUNT): ++ t = Thread(target=worker) ++ t.daemon = True ++ t.start() ++ ++ for item in range(WORK_ITEM_COUNT): ++ q.put(item) ++ q.join() # block until all tasks are done ++ #yappi.get_func_stats().sort("callcount").print_all() ++ yappi.stop() ++ ++ def test_temporary_lock_waiting(self): ++ yappi.start() ++ _lock = threading.Lock() ++ ++ def worker(): ++ _lock.acquire() ++ try: ++ time.sleep(1.0) ++ finally: ++ _lock.release() ++ ++ t1 = threading.Thread(target=worker) ++ t2 = threading.Thread(target=worker) ++ t1.start() ++ t2.start() ++ t1.join() ++ t2.join() ++ #yappi.get_func_stats().sort("callcount").print_all() ++ yappi.stop() ++ ++ @unittest.skipIf(os.name != "posix", "requires Posix compliant OS") ++ def test_signals_with_blocking_calls(self): ++ import signal, os, time ++ ++ # just to verify if signal is handled correctly and stats/yappi are not corrupted. ++ def handler(signum, frame): ++ raise Exception("Signal handler executed!") ++ ++ yappi.start() ++ signal.signal(signal.SIGALRM, handler) ++ signal.alarm(1) ++ self.assertRaises(Exception, time.sleep, 2) ++ stats = yappi.get_func_stats() ++ fsh = utils.find_stat_by_name(stats, "handler") ++ self.assertTrue(fsh is not None) ++ ++ @unittest.skipIf(not sys.version_info >= (3, 2), "requires Python 3.2") ++ def test_concurrent_futures(self): ++ yappi.start() ++ from concurrent.futures import ThreadPoolExecutor ++ with ThreadPoolExecutor(max_workers=5) as executor: ++ f = executor.submit(pow, 5, 2) ++ self.assertEqual(f.result(), 25) ++ time.sleep(1.0) ++ yappi.stop() ++ ++ @unittest.skipIf(not sys.version_info >= (3, 2), "requires Python 3.2") ++ def test_barrier(self): ++ yappi.start() ++ b = threading.Barrier(2, timeout=1) ++ ++ def worker(): ++ try: ++ b.wait() ++ except threading.BrokenBarrierError: ++ pass ++ except Exception: ++ raise Exception("BrokenBarrierError not raised") ++ ++ t1 = threading.Thread(target=worker) ++ t1.start() ++ #b.wait() ++ t1.join() ++ yappi.stop() ++ ++ ++class NonRecursiveFunctions(utils.YappiUnitTestCase): ++ ++ def test_abcd(self): ++ _timings = {"a_1": 6, "b_1": 5, "c_1": 3, "d_1": 1} ++ _yappi._set_test_timings(_timings) ++ ++ def a(): ++ b() ++ ++ def b(): ++ c() ++ ++ def c(): ++ d() ++ ++ def d(): ++ pass ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ fsc = utils.find_stat_by_name(stats, 'c') ++ fsd = utils.find_stat_by_name(stats, 'd') ++ cfsab = fsa.children[fsb] ++ cfsbc = fsb.children[fsc] ++ cfscd = fsc.children[fsd] ++ ++ self.assertEqual(fsa.ttot, 6) ++ self.assertEqual(fsa.tsub, 1) ++ self.assertEqual(fsb.ttot, 5) ++ self.assertEqual(fsb.tsub, 2) ++ self.assertEqual(fsc.ttot, 3) ++ self.assertEqual(fsc.tsub, 2) ++ self.assertEqual(fsd.ttot, 1) ++ self.assertEqual(fsd.tsub, 1) ++ self.assertEqual(cfsab.ttot, 5) ++ self.assertEqual(cfsab.tsub, 2) ++ self.assertEqual(cfsbc.ttot, 3) ++ self.assertEqual(cfsbc.tsub, 2) ++ self.assertEqual(cfscd.ttot, 1) ++ self.assertEqual(cfscd.tsub, 1) ++ ++ def test_stop_in_middle(self): ++ _timings = {"a_1": 6, "b_1": 4} ++ _yappi._set_test_timings(_timings) ++ ++ def a(): ++ b() ++ yappi.stop() ++ ++ def b(): ++ time.sleep(0.2) ++ ++ yappi.start() ++ a() ++ stats = yappi.get_func_stats() ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ ++ self.assertEqual(fsa.ncall, 1) ++ self.assertEqual(fsa.nactualcall, 0) ++ self.assertEqual(fsa.ttot, 0) # no call_leave called ++ self.assertEqual(fsa.tsub, 0) # no call_leave called ++ self.assertEqual(fsb.ttot, 4) ++ ++ ++class RecursiveFunctions(utils.YappiUnitTestCase): ++ ++ def test_fibonacci(self): ++ ++ def fib(n): ++ if n > 1: ++ return fib(n - 1) + fib(n - 2) ++ else: ++ return n ++ ++ stats = utils.run_and_get_func_stats(fib, 22) ++ fs = utils.find_stat_by_name(stats, 'fib') ++ self.assertEqual(fs.ncall, 57313) ++ self.assertEqual(fs.ttot, fs.tsub) ++ ++ def test_abcadc(self): ++ _timings = { ++ "a_1": 20, ++ "b_1": 19, ++ "c_1": 17, ++ "a_2": 13, ++ "d_1": 12, ++ "c_2": 10, ++ "a_3": 5 ++ } ++ _yappi._set_test_timings(_timings) ++ ++ def a(n): ++ if n == 3: ++ return ++ if n == 1 + 1: ++ d(n) ++ else: ++ b(n) ++ ++ def b(n): ++ c(n) ++ ++ def c(n): ++ a(n + 1) ++ ++ def d(n): ++ c(n) ++ ++ stats = utils.run_and_get_func_stats(a, 1) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ fsc = utils.find_stat_by_name(stats, 'c') ++ fsd = utils.find_stat_by_name(stats, 'd') ++ self.assertEqual(fsa.ncall, 3) ++ self.assertEqual(fsa.nactualcall, 1) ++ self.assertEqual(fsa.ttot, 20) ++ self.assertEqual(fsa.tsub, 7) ++ self.assertEqual(fsb.ttot, 19) ++ self.assertEqual(fsb.tsub, 2) ++ self.assertEqual(fsc.ttot, 17) ++ self.assertEqual(fsc.tsub, 9) ++ self.assertEqual(fsd.ttot, 12) ++ self.assertEqual(fsd.tsub, 2) ++ cfsca = fsc.children[fsa] ++ self.assertEqual(cfsca.nactualcall, 0) ++ self.assertEqual(cfsca.ncall, 2) ++ self.assertEqual(cfsca.ttot, 13) ++ self.assertEqual(cfsca.tsub, 6) ++ ++ def test_aaaa(self): ++ _timings = {"d_1": 9, "d_2": 7, "d_3": 3, "d_4": 2} ++ _yappi._set_test_timings(_timings) ++ ++ def d(n): ++ if n == 3: ++ return ++ d(n + 1) ++ ++ stats = utils.run_and_get_func_stats(d, 0) ++ fsd = utils.find_stat_by_name(stats, 'd') ++ self.assertEqual(fsd.ncall, 4) ++ self.assertEqual(fsd.nactualcall, 1) ++ self.assertEqual(fsd.ttot, 9) ++ self.assertEqual(fsd.tsub, 9) ++ cfsdd = fsd.children[fsd] ++ self.assertEqual(cfsdd.ttot, 7) ++ self.assertEqual(cfsdd.tsub, 7) ++ self.assertEqual(cfsdd.ncall, 3) ++ self.assertEqual(cfsdd.nactualcall, 0) ++ ++ def test_abcabc(self): ++ _timings = { ++ "a_1": 20, ++ "b_1": 19, ++ "c_1": 17, ++ "a_2": 13, ++ "b_2": 11, ++ "c_2": 9, ++ "a_3": 6 ++ } ++ _yappi._set_test_timings(_timings) ++ ++ def a(n): ++ if n == 3: ++ return ++ else: ++ b(n) ++ ++ def b(n): ++ c(n) ++ ++ def c(n): ++ a(n + 1) ++ ++ stats = utils.run_and_get_func_stats(a, 1) ++ 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, 3) ++ self.assertEqual(fsa.nactualcall, 1) ++ self.assertEqual(fsa.ttot, 20) ++ self.assertEqual(fsa.tsub, 9) ++ self.assertEqual(fsb.ttot, 19) ++ self.assertEqual(fsb.tsub, 4) ++ self.assertEqual(fsc.ttot, 17) ++ self.assertEqual(fsc.tsub, 7) ++ cfsab = fsa.children[fsb] ++ cfsbc = fsb.children[fsc] ++ cfsca = fsc.children[fsa] ++ self.assertEqual(cfsab.ttot, 19) ++ self.assertEqual(cfsab.tsub, 4) ++ self.assertEqual(cfsbc.ttot, 17) ++ self.assertEqual(cfsbc.tsub, 7) ++ self.assertEqual(cfsca.ttot, 13) ++ self.assertEqual(cfsca.tsub, 8) ++ ++ def test_abcbca(self): ++ _timings = {"a_1": 10, "b_1": 9, "c_1": 7, "b_2": 4, "c_2": 2, "a_2": 1} ++ _yappi._set_test_timings(_timings) ++ self._ncall = 1 ++ ++ def a(): ++ if self._ncall == 1: ++ b() ++ else: ++ return ++ ++ def b(): ++ c() ++ ++ def c(): ++ if self._ncall == 1: ++ self._ncall += 1 ++ b() ++ else: ++ a() ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ fsc = utils.find_stat_by_name(stats, 'c') ++ cfsab = fsa.children[fsb] ++ cfsbc = fsb.children[fsc] ++ cfsca = fsc.children[fsa] ++ self.assertEqual(fsa.ttot, 10) ++ self.assertEqual(fsa.tsub, 2) ++ self.assertEqual(fsb.ttot, 9) ++ self.assertEqual(fsb.tsub, 4) ++ self.assertEqual(fsc.ttot, 7) ++ self.assertEqual(fsc.tsub, 4) ++ self.assertEqual(cfsab.ttot, 9) ++ self.assertEqual(cfsab.tsub, 2) ++ self.assertEqual(cfsbc.ttot, 7) ++ self.assertEqual(cfsbc.tsub, 4) ++ self.assertEqual(cfsca.ttot, 1) ++ self.assertEqual(cfsca.tsub, 1) ++ self.assertEqual(cfsca.ncall, 1) ++ self.assertEqual(cfsca.nactualcall, 0) ++ ++ def test_aabccb(self): ++ _timings = { ++ "a_1": 13, ++ "a_2": 11, ++ "b_1": 9, ++ "c_1": 5, ++ "c_2": 3, ++ "b_2": 1 ++ } ++ _yappi._set_test_timings(_timings) ++ self._ncall = 1 ++ ++ def a(): ++ if self._ncall == 1: ++ self._ncall += 1 ++ a() ++ else: ++ b() ++ ++ def b(): ++ if self._ncall == 3: ++ return ++ else: ++ c() ++ ++ def c(): ++ if self._ncall == 2: ++ self._ncall += 1 ++ c() ++ else: ++ b() ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ fsc = utils.find_stat_by_name(stats, 'c') ++ cfsaa = fsa.children[fsa.index] ++ cfsab = fsa.children[fsb] ++ cfsbc = fsb.children[fsc.full_name] ++ cfscc = fsc.children[fsc] ++ cfscb = fsc.children[fsb] ++ self.assertEqual(fsb.ttot, 9) ++ self.assertEqual(fsb.tsub, 5) ++ self.assertEqual(cfsbc.ttot, 5) ++ self.assertEqual(cfsbc.tsub, 2) ++ self.assertEqual(fsa.ttot, 13) ++ self.assertEqual(fsa.tsub, 4) ++ self.assertEqual(cfsab.ttot, 9) ++ self.assertEqual(cfsab.tsub, 4) ++ self.assertEqual(cfsaa.ttot, 11) ++ self.assertEqual(cfsaa.tsub, 2) ++ self.assertEqual(fsc.ttot, 5) ++ self.assertEqual(fsc.tsub, 4) ++ ++ def test_abaa(self): ++ _timings = {"a_1": 13, "b_1": 10, "a_2": 9, "a_3": 5} ++ _yappi._set_test_timings(_timings) ++ ++ self._ncall = 1 ++ ++ def a(): ++ if self._ncall == 1: ++ b() ++ elif self._ncall == 2: ++ self._ncall += 1 ++ a() ++ else: ++ return ++ ++ def b(): ++ self._ncall += 1 ++ a() ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ cfsaa = fsa.children[fsa] ++ cfsba = fsb.children[fsa] ++ self.assertEqual(fsb.ttot, 10) ++ self.assertEqual(fsb.tsub, 1) ++ self.assertEqual(fsa.ttot, 13) ++ self.assertEqual(fsa.tsub, 12) ++ self.assertEqual(cfsaa.ttot, 5) ++ self.assertEqual(cfsaa.tsub, 5) ++ self.assertEqual(cfsba.ttot, 9) ++ self.assertEqual(cfsba.tsub, 4) ++ ++ def test_aabb(self): ++ _timings = {"a_1": 13, "a_2": 10, "b_1": 9, "b_2": 5} ++ _yappi._set_test_timings(_timings) ++ ++ self._ncall = 1 ++ ++ def a(): ++ if self._ncall == 1: ++ self._ncall += 1 ++ a() ++ elif self._ncall == 2: ++ b() ++ else: ++ return ++ ++ def b(): ++ if self._ncall == 2: ++ self._ncall += 1 ++ b() ++ else: ++ return ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ cfsaa = fsa.children[fsa] ++ cfsab = fsa.children[fsb] ++ cfsbb = fsb.children[fsb] ++ self.assertEqual(fsa.ttot, 13) ++ self.assertEqual(fsa.tsub, 4) ++ self.assertEqual(fsb.ttot, 9) ++ self.assertEqual(fsb.tsub, 9) ++ self.assertEqual(cfsaa.ttot, 10) ++ self.assertEqual(cfsaa.tsub, 1) ++ self.assertEqual(cfsab.ttot, 9) ++ self.assertEqual(cfsab.tsub, 4) ++ self.assertEqual(cfsbb.ttot, 5) ++ self.assertEqual(cfsbb.tsub, 5) ++ ++ def test_abbb(self): ++ _timings = {"a_1": 13, "b_1": 10, "b_2": 6, "b_3": 1} ++ _yappi._set_test_timings(_timings) ++ ++ self._ncall = 1 ++ ++ def a(): ++ if self._ncall == 1: ++ b() ++ ++ def b(): ++ if self._ncall == 3: ++ return ++ self._ncall += 1 ++ b() ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ cfsab = fsa.children[fsb] ++ cfsbb = fsb.children[fsb] ++ self.assertEqual(fsa.ttot, 13) ++ self.assertEqual(fsa.tsub, 3) ++ self.assertEqual(fsb.ttot, 10) ++ self.assertEqual(fsb.tsub, 10) ++ self.assertEqual(fsb.ncall, 3) ++ self.assertEqual(fsb.nactualcall, 1) ++ self.assertEqual(cfsab.ttot, 10) ++ self.assertEqual(cfsab.tsub, 4) ++ self.assertEqual(cfsbb.ttot, 6) ++ self.assertEqual(cfsbb.tsub, 6) ++ self.assertEqual(cfsbb.nactualcall, 0) ++ self.assertEqual(cfsbb.ncall, 2) ++ ++ def test_aaab(self): ++ _timings = {"a_1": 13, "a_2": 10, "a_3": 6, "b_1": 1} ++ _yappi._set_test_timings(_timings) ++ ++ self._ncall = 1 ++ ++ def a(): ++ if self._ncall == 3: ++ b() ++ return ++ self._ncall += 1 ++ a() ++ ++ def b(): ++ return ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ cfsaa = fsa.children[fsa] ++ cfsab = fsa.children[fsb] ++ self.assertEqual(fsa.ttot, 13) ++ self.assertEqual(fsa.tsub, 12) ++ self.assertEqual(fsb.ttot, 1) ++ self.assertEqual(fsb.tsub, 1) ++ self.assertEqual(cfsaa.ttot, 10) ++ self.assertEqual(cfsaa.tsub, 9) ++ self.assertEqual(cfsab.ttot, 1) ++ self.assertEqual(cfsab.tsub, 1) ++ ++ def test_abab(self): ++ _timings = {"a_1": 13, "b_1": 10, "a_2": 6, "b_2": 1} ++ _yappi._set_test_timings(_timings) ++ ++ self._ncall = 1 ++ ++ def a(): ++ b() ++ ++ def b(): ++ if self._ncall == 2: ++ return ++ self._ncall += 1 ++ a() ++ ++ stats = utils.run_and_get_func_stats(a) ++ fsa = utils.find_stat_by_name(stats, 'a') ++ fsb = utils.find_stat_by_name(stats, 'b') ++ cfsab = fsa.children[fsb] ++ cfsba = fsb.children[fsa] ++ self.assertEqual(fsa.ttot, 13) ++ self.assertEqual(fsa.tsub, 8) ++ self.assertEqual(fsb.ttot, 10) ++ self.assertEqual(fsb.tsub, 5) ++ self.assertEqual(cfsab.ttot, 10) ++ self.assertEqual(cfsab.tsub, 5) ++ self.assertEqual(cfsab.ncall, 2) ++ self.assertEqual(cfsab.nactualcall, 1) ++ self.assertEqual(cfsba.ttot, 6) ++ self.assertEqual(cfsba.tsub, 5) ++ ++ ++if __name__ == '__main__': ++ # import sys;sys.argv = ['', 'BasicUsage.test_run_as_script'] ++ # import sys;sys.argv = ['', 'MultithreadedScenarios.test_subsequent_profile'] ++ unittest.main() +--- a/tests/test_gevent.py ++++ b/tests/test_gevent.py +@@ -4,7 +4,7 @@ import yappi + import gevent + from gevent.event import Event + import threading +-from utils import ( ++from .utils import ( + YappiUnitTestCase, find_stat_by_name, burn_cpu, burn_io, + burn_io_gevent + ) +--- a/tests/test_hooks.py ++++ b/tests/test_hooks.py +@@ -5,7 +5,7 @@ import unittest + import time + + import yappi +-import utils ++import tests.utils as utils + + + def a(): +--- a/tests/test_tags.py ++++ b/tests/test_tags.py +@@ -2,7 +2,7 @@ import unittest + import yappi + import threading + import time +-from utils import YappiUnitTestCase, find_stat_by_name, burn_cpu, burn_io ++from .utils import YappiUnitTestCase, find_stat_by_name, burn_cpu, burn_io + + + class MultiThreadTests(YappiUnitTestCase): -- cgit v1.2.3