viztracer 1.0.4__tar.gz → 1.1.0__tar.gz

viztracer-1.1.0/PKG-INFO

@@ -0,0 +1,316 @@
+Metadata-Version: 2.4
+Name: viztracer
+Version: 1.1.0
+Summary: A debugging and profiling tool that can trace and visualize python code execution
+Author-email: Tian Gao <gaogaotiantian@hotmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/gaogaotiantian/viztracer
+Project-URL: Documentation, https://viztracer.readthedocs.io
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Bug Tracking
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.txt
+Requires-Dist: objprint>=0.3.0
+Provides-Extra: full
+Requires-Dist: orjson; extra == "full"
+Dynamic: license-file
+
+# VizTracer
+
+[![build](https://github.com/gaogaotiantian/viztracer/workflows/build/badge.svg)](https://github.com/gaogaotiantian/viztracer/actions?query=workflow%3Abuild)  [![flake8](https://github.com/gaogaotiantian/viztracer/workflows/lint/badge.svg)](https://github.com/gaogaotiantian/viztracer/actions?query=workflow%3ALint)  [![readthedocs](https://img.shields.io/readthedocs/viztracer)](https://viztracer.readthedocs.io/en/stable/)  [![coverage](https://img.shields.io/codecov/c/github/gaogaotiantian/viztracer)](https://codecov.io/gh/gaogaotiantian/viztracer)  [![pypi](https://img.shields.io/pypi/v/viztracer.svg)](https://pypi.org/project/viztracer/)  [![Visual Studio Marketplace Version](https://img.shields.io/visual-studio-marketplace/v/gaogaotiantian.viztracer-vscode?logo=visual-studio)](https://marketplace.visualstudio.com/items?itemName=gaogaotiantian.viztracer-vscode)  [![support-version](https://img.shields.io/pypi/pyversions/viztracer)](https://img.shields.io/pypi/pyversions/viztracer)  [![license](https://img.shields.io/github/license/gaogaotiantian/viztracer)](https://github.com/gaogaotiantian/viztracer/blob/master/LICENSE)  [![commit](https://img.shields.io/github/last-commit/gaogaotiantian/viztracer)](https://github.com/gaogaotiantian/viztracer/commits/master)  [![sponsor](https://img.shields.io/badge/%E2%9D%A4-Sponsor%20me-%23c96198?style=flat&logo=GitHub)](https://github.com/sponsors/gaogaotiantian)
+
+VizTracer is a low-overhead logging/debugging/profiling tool that can trace and visualize your python code execution.
+
+The front-end UI is powered by [Perfetto](https://perfetto.dev/). **Use "AWSD" to zoom/navigate**.
+More help can be found in "Support - Controls".
+
+[![example_img](https://github.com/gaogaotiantian/viztracer/blob/master/img/example.png)](https://github.com/gaogaotiantian/viztracer/blob/master/img/example.png)
+
+
+## Highlights
+
+* Detailed function entry/exit information on timeline with source code
+* Super easy to use, no source code change for most features, no package dependency
+* Low overhead, probably the fastest tracer in the market
+* Supports threading, multiprocessing, subprocess, async and PyTorch
+* Powerful front-end, able to render GB-level trace smoothly
+* Works on Linux/MacOS/Windows
+
+## Install
+
+The preferred way to install VizTracer is via pip
+
+```sh
+pip install viztracer
+```
+
+## Basic Usage
+
+### Command Line
+
+```sh
+# Instead of "python3 my_script.py arg1 arg2"
+viztracer my_script.py arg1 arg2
+```
+
+<details>
+
+<summary>
+A <code>result.json</code> file will be generated, which you can open with <code>vizviewer</code>
+</summary>
+
+```sh
+# You can display all the files in a directory and open them in browser too
+vizviewer ./
+# For very large trace files, try external trace processor
+vizviewer --use_external_processor result.json
+```
+
+vizviewer will host an HTTP server on ``http://localhost:9001``. You can also open your browser and use that address.
+
+If you do not want vizviewer to open the webbrowser automatically, you can use
+
+```sh
+vizviewer --server_only result.json
+```
+
+If you just need to bring up the trace report once, and do not want the persistent server, use
+
+```sh
+vizviewer --once result.json
+```
+
+</details>
+
+```sh
+vizviewer result.json
+```
+
+A [VS Code Extension](https://marketplace.visualstudio.com/items?itemName=gaogaotiantian.viztracer-vscode)
+is available to make your life even easier.
+
+<p align="center">
+    <img src="https://github.com/gaogaotiantian/viztracer-vscode/raw/master/assets/demo.gif" />
+</p>
+
+<details>
+
+<summary>
+Add <code>--open</code> to open the reports right after tracing
+</summary>
+
+```sh
+viztracer --open my_script.py arg1 arg2
+viztracer -o result.html --open my_script.py arg1 arg2
+```
+
+</details>
+
+<details>
+
+<summary>
+modules and console scripts(like <code>flask</code>) are supported as well
+</summary>
+
+```sh
+viztracer -m your_module
+```
+
+```sh
+viztracer flask run
+```
+
+</details>
+
+### Inline
+
+You can also manually start/stop VizTracer in your script as well.
+
+```python
+from viztracer import VizTracer
+
+tracer = VizTracer()
+tracer.start()
+# Something happens here
+tracer.stop()
+tracer.save() # also takes output_file as an optional argument
+```
+
+Or, you can do it with ```with``` statement
+
+```python
+with VizTracer(output_file="optional.json") as tracer:
+    # Something happens here
+```
+
+### Jupyter
+
+If you are using Jupyter, you can use viztracer cell magics.
+
+```python
+# You need to load the extension first
+%load_ext viztracer
+```
+
+```python
+%%viztracer
+# Your code after
+```
+
+A ``VizTracer Report`` button will appear after the cell and you can click it to view the results
+
+### PyTorch
+
+VizTracer can log native calls and GPU events of PyTorch (based on `torch.profiler`) with
+``--log_torch``.
+
+```python
+with VizTracer(log_torch=True) as tracer:
+    # Your torch code
+```
+
+```sh
+viztracer --log_torch your_model.py
+```
+
+## Advanced Usage
+
+### Trace Filter
+
+VizTracer can filter out the data you don't want to reduce overhead and keep info of a longer time period before you dump the log.
+
+* [Min Duration](https://viztracer.readthedocs.io/en/stable/filter.html#min-duration)
+* [Max Stack Depth](https://viztracer.readthedocs.io/en/stable/filter.html#max-stack-depth)
+* [Include Files](https://viztracer.readthedocs.io/en/stable/filter.html#include-files)
+* [Exclude Files](https://viztracer.readthedocs.io/en/stable/filter.html#exclude-files)
+* [Ignore C Function](https://viztracer.readthedocs.io/en/stable/filter.html#ignore-c-function)
+* [Sparse Log](https://viztracer.readthedocs.io/en/stable/filter.html#log-sparse)
+
+### Extra Logs without Code Change
+
+VizTracer can log extra information without changing your source code
+
+* [Any Variable/Attribute with RegEx](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-variable)
+* [Function Entry](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-function-entry)
+* [Variables in Specified Function](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-function-execution)
+* [Garbage Collector Operation](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-garbage-collector)
+* [Function Input Arguments](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-function-arguments)
+* [Function Return Value](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-function-return-value)
+* [Audit Events](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-audit)
+* [Raised Exceptions](https://viztracer.readthedocs.io/en/stable/extra_log.html#log-exception)
+
+### Add Custom Event
+
+VizTracer supports inserting custom events while the program is running. This works like a print debug, but you can know when this print happens while looking at trace data.
+
+* [Instant Event](https://viztracer.readthedocs.io/en/stable/custom_event_intro.html#instant-event)
+* [Variable Event](https://viztracer.readthedocs.io/en/stable/custom_event_intro.html#variable-event)
+* [Duration Event](https://viztracer.readthedocs.io/en/stable/custom_event_intro.html#duration-event)
+
+## Misc
+
+### Multi Thread Support
+
+For Python3.12+, VizTracer supports Python-level multi-thread tracing without the need to do any modification to your code.
+
+For versions before 3.12, VizTracer supports python native ```threading``` module. Just start ```VizTracer``` before you create threads and it will just work.
+
+For other multi-thread scenarios, you can use ``enable_thread_tracing()`` to notice VizTracer about the thread to trace it.
+
+[![example_img](https://github.com/gaogaotiantian/viztracer/blob/master/img/multithread_example.png)](https://github.com/gaogaotiantian/viztracer/blob/master/img/multithread_example.png)
+
+Refer to [multi thread docs](https://viztracer.readthedocs.io/en/stable/concurrency.html) for details
+
+
+### Multi Process Support
+
+VizTracer supports ```subprocess```, ```multiprocessing```, ```os.fork()```, ```concurrent.futures```, and ```loky``` out of the box.
+
+For more general multi-process cases, VizTracer can support with some extra steps.
+
+[![example_img](https://github.com/gaogaotiantian/viztracer/blob/master/img/multiprocess_example.png)](https://github.com/gaogaotiantian/viztracer/blob/master/img/multiprocess_example.png)
+
+Refer to [multi process docs](https://viztracer.readthedocs.io/en/stable/concurrency.html) for details
+
+### Async Support
+
+VizTracer supports ```asyncio``` natively, but could enhance the report by using ```--log_async```.
+
+[![example_img](https://github.com/gaogaotiantian/viztracer/blob/master/img/async_example.png)](https://github.com/gaogaotiantian/viztracer/blob/master/img/async_example.png)
+
+Refer to [async docs](https://viztracer.readthedocs.io/en/stable/concurrency.html) for details
+
+### Flamegraph
+
+Perfetto supports native flamegraph, just select slices on the UI and choose "Slice Flamegraph".
+
+[![example_img](https://github.com/gaogaotiantian/viztracer/blob/master/img/flamegraph.png)](https://github.com/gaogaotiantian/viztracer/blob/master/img/flamegraph.png)
+
+### Remote attach
+
+VizTracer supports remote attach to an arbitrary Python process to trace it, as long as viztracer is importable
+
+Refer to [remote attach docs](https://viztracer.readthedocs.io/en/stable/remote_attach.html)
+
+### JSON alternative
+
+VizTracer needs to dump the internal data to json format. It is recommended for the users to install ```orjson```, which is much faster than the builtin ```json``` library. VizTracer will try to import ```orjson``` and fall back to the builtin ```json``` library if ```orjson``` does not exist.
+
+## Performance
+
+VizTracer puts in a lot of effort to achieve low overhead. The actual performance impact largely depends on your application.
+For typical codebases, the overhead is expected to be below 1x. If your code has infrequent function calls,
+the overhead could be minimal.
+
+<details>
+
+<summary>
+Detailed explanation
+</summary>
+
+The overhead introduced by VizTracer is basically a fixed amount of time during function entry and exit, so the more time spent on
+function entries and exits, the more overhead will be observed. A pure recursive ```fib``` function could suffer 3x-4x overhead
+on Python3.11+ (when the Python call is optimized, before that Python call was slower so the overhead ratio would be less).
+
+In the real life scenario, your code should not spend too much time on function calls (they don't really do anything useful), so
+the overhead would be much smaller.
+
+Many techniques are applied to minimize the overall overhead during code execution to reduce the inevitable skew introduced by
+VizTracer (the report saving part is not as critical). For example, VizTracer tries to use the CPU timestamp counter instead of
+a syscall to get the time when available. On Python 3.12+, VizTracer uses ```sys.monitoring``` which has less overhead than
+```sys.setprofile```. All of the efforts made it observably faster than ```cProfile```, the Python stdlib profiler.
+
+However, VizTracer is a tracer, which means it has to record every single function entry and exit, so it can't be as fast as
+the sampling profilers - they are not the same thing. With the extra overhead, VizTracer provides a lot more information than
+normal sampling profilers.
+
+</details>
+
+## Documentation
+
+For full documentation, please see [https://viztracer.readthedocs.io/en/stable](https://viztracer.readthedocs.io/en/stable)
+
+## Bugs/Requests
+
+Please send bug reports and feature requests through [github issue tracker](https://github.com/gaogaotiantian/viztracer/issues). VizTracer is currently under development now and it's open to any constructive suggestions.
+
+## License
+
+Copyright 2020-2025 Tian Gao.
+
+Distributed under the terms of the  [Apache 2.0 license](https://github.com/gaogaotiantian/viztracer/blob/master/LICENSE).

{viztracer-1.0.4 → viztracer-1.1.0}/pyproject.toml

@@ -8,18 +8,19 @@ authors = [{name = "Tian Gao", email = "gaogaotiantian@hotmail.com"}]
 description = "A debugging and profiling tool that can trace and visualize python code execution"
 dependencies = ["objprint>=0.3.0"]
 readme = "README.md"
-requires-python = ">=3.9"
-license = {file = "LICENSE"}
+requires-python = ">=3.10"
+license = "Apache-2.0"
 dynamic = ["version"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: Free Threading",
+    "Programming Language :: Python :: Free Threading :: 3 - Stable",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
     "Operating System :: MacOS",
     "Operating System :: POSIX :: Linux",
     "Operating System :: Microsoft :: Windows",

{viztracer-1.0.4 → viztracer-1.1.0}/src/viztracer/__init__.py

@@ -1,7 +1,7 @@
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
 # For details: https://github.com/gaogaotiantian/viztracer/blob/master/NOTICE.txt
 
-__version__ = "1.0.4"
+__version__ = "1.1.0"
 
 
 from .cellmagic import load_ipython_extension

{viztracer-1.0.4 → viztracer-1.1.0}/src/viztracer/code_monkey.py

@@ -5,7 +5,7 @@ import ast
 import copy
 import re
 from functools import reduce
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable
 
 from .util import color_print
 
@@ -18,13 +18,13 @@ class AstTransformer(ast.NodeTransformer):
         self.curr_lineno: int = 0
         self.log_func_exec_enable: bool = False
 
-    def visit_Assign(self, node: ast.Assign) -> Union[ast.stmt, list[ast.stmt]]:
+    def visit_Assign(self, node: ast.Assign) -> ast.stmt | list[ast.stmt]:
         return self._visit_generic_assign(node)
 
-    def visit_AugAssign(self, node: ast.AugAssign) -> Union[ast.stmt, list[ast.stmt]]:
+    def visit_AugAssign(self, node: ast.AugAssign) -> ast.stmt | list[ast.stmt]:
         return self._visit_generic_assign(node)
 
-    def visit_AnnAssign(self, node: ast.AnnAssign) -> Union[ast.stmt, list[ast.stmt]]:
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> ast.stmt | list[ast.stmt]:
         return self._visit_generic_assign(node)
 
     def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
@@ -69,13 +69,13 @@ class AstTransformer(ast.NodeTransformer):
                 node.body = instrumented_nodes + node.body
         return node
 
-    def visit_Raise(self, node: ast.Raise) -> Union[ast.AST, list[ast.AST]]:
+    def visit_Raise(self, node: ast.Raise) -> ast.AST | list[ast.AST]:
         if self.inst_type == "log_exception":
             instrument_node = self.get_instrument_node_by_node("Exception", node.exc)
             return [instrument_node, node]
         return node
 
-    def _visit_generic_assign(self, node: Union[ast.Assign, ast.AugAssign, ast.AnnAssign]) -> list[ast.stmt]:
+    def _visit_generic_assign(self, node: ast.Assign | ast.AugAssign | ast.AnnAssign) -> list[ast.stmt]:
         self.generic_visit(node)
         ret: list[ast.stmt] = [node]
         self.curr_lineno = node.lineno
@@ -174,7 +174,7 @@ class AstTransformer(ast.NodeTransformer):
         else:
             raise ValueError(f"{name} is not supported")
 
-    def get_instrument_node_by_node(self, trigger: str, node: Optional[ast.expr]) -> ast.Expr:
+    def get_instrument_node_by_node(self, trigger: str, node: ast.expr | None) -> ast.Expr:
         var_node: ast.expr
         if node is None:
             name = f"{trigger}"
@@ -235,17 +235,14 @@ class AstTransformer(ast.NodeTransformer):
                 n.ctx = ast.Load()  # type: ignore
         return new_node
 
-    def get_string_of_expr(self, node: Union[ast.expr, ast.slice]) -> str:
+    def get_string_of_expr(self, node: ast.expr | ast.slice) -> str:
         """
         Try to do "unparse" of the node
         """
         if isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Constant):
-            if isinstance(node.value, str):
-                return f"'{node.value}'"
-            else:
-                return f"{node.value}"
+            return repr(node.value)
         elif isinstance(node, ast.Attribute):
             return f"{self.get_string_of_expr(node.value)}.{node.attr}"
         elif isinstance(node, ast.Subscript):
@@ -333,7 +330,7 @@ class CodeMonkey:
     def __init__(self, file_name: str) -> None:
         self.file_name: str = file_name
         self._compile: Callable = compile
-        self.source_processor: Optional[SourceProcessor] = None
+        self.source_processor: SourceProcessor | None = None
         self.ast_transformers: list[AstTransformer] = []
 
     def add_instrument(self, inst_type: str, inst_args: dict[str, dict]) -> None:

{viztracer-1.0.4 → viztracer-1.1.0}/src/viztracer/decorator.py

@@ -5,7 +5,7 @@ import functools
 import multiprocessing
 import os
 import time
-from typing import Any, Callable, Optional, TypeVar, Union, overload
+from typing import Any, Callable, TypeVar, overload
 
 from .viztracer import VizTracer, get_tracer
 
@@ -15,19 +15,18 @@ R = TypeVar("R")
 
 @overload
 def ignore_function(method: None,
-                    tracer: Optional[VizTracer] = None) -> Callable[[Callable[..., R]], Callable[..., R]]:
+                    tracer: VizTracer | None = None) -> Callable[[Callable[..., R]], Callable[..., R]]:
     pass  # pragma: no cover
 
 
 @overload
 def ignore_function(method: Callable[..., R],
-                    tracer: Optional[VizTracer] = None) -> Callable[..., R]:
+                    tracer: VizTracer | None = None) -> Callable[..., R]:
     pass  # pragma: no cover
 
 
-def ignore_function(method: Optional[Callable[..., R]] = None,
-                    tracer: Optional[VizTracer] = None) -> Union[Callable[..., R],
-                                                                 Callable[[Callable[..., R]], Callable[..., R]]]:
+def ignore_function(method: Callable[..., R] | None = None,
+                    tracer: VizTracer | None = None) -> Callable[..., R] | Callable[[Callable[..., R]], Callable[..., R]]:
 
     def inner(func: Callable[..., R]) -> Callable[..., R]:
 
@@ -65,10 +64,9 @@ def trace_and_save(method: Callable[..., R],
     pass  # pragma: no cover
 
 
-def trace_and_save(method: Optional[Callable[..., R]] = None,
+def trace_and_save(method: Callable[..., R] | None = None,
                    output_dir: str = "./",
-                   **viztracer_kwargs) -> Union[Callable[..., R],
-                                                Callable[[Callable[..., R]], Callable[..., R]]]:
+                   **viztracer_kwargs) -> Callable[..., R] | Callable[[Callable[..., R]], Callable[..., R]]:
 
     def inner(func: Callable[..., R]) -> Callable[..., R]:
 
@@ -158,10 +156,9 @@ def log_sparse(func: Callable[..., R],
     pass  # pragma: no cover
 
 
-def log_sparse(func: Optional[Callable[..., R]] = None,
+def log_sparse(func: Callable[..., R] | None = None,
                stack_depth: int = 0,
-               dynamic_tracer_check: bool = False) -> Union[Callable[..., R],
-                                                            Callable[[Callable[..., R]], Callable[..., R]]]:
+               dynamic_tracer_check: bool = False) -> Callable[..., R] | Callable[[Callable[..., R]], Callable[..., R]]:
     if func is None:
         return functools.partial(_log_sparse_wrapper, stack_depth=stack_depth, dynamic_tracer_check=dynamic_tracer_check)
     return _log_sparse_wrapper(func=func, stack_depth=stack_depth, dynamic_tracer_check=dynamic_tracer_check)

{viztracer-1.0.4 → viztracer-1.1.0}/src/viztracer/event_base.py

@@ -2,7 +2,7 @@
 # For details: https://github.com/gaogaotiantian/viztracer/blob/master/NOTICE.txt
 
 import functools
-from typing import Any, Callable, Literal, Optional
+from typing import Any, Callable, Literal
 
 from .viztracer import VizTracer
 
@@ -59,7 +59,7 @@ class _EventBase:
         self._viztracer_log()
 
     @staticmethod
-    def triggerlog(method: Optional[Callable] = None,
+    def triggerlog(method: Callable | None = None,
                    when: Literal["after", "before", "both"] = "after") -> Callable:
         if when not in ["after", "before", "both"]:
             raise ValueError(f"when has to be one of 'after', 'before' or 'both', not {when}")

{viztracer-1.0.4 → viztracer-1.1.0}/src/viztracer/functree.py

@@ -4,18 +4,18 @@
 import bisect
 import copy
 import re
-from typing import Any, Generator, Optional
+from typing import Any, Generator
 
 
 class FuncTreeNode:
     name_regex = r"(.*) \((.*?):([0-9]+)\)"
 
-    def __init__(self, event: Optional[dict[str, Any]] = None) -> None:
-        self.filename: Optional[str] = None
-        self.lineno: Optional[int] = None
-        self.is_python: Optional[bool] = False
-        self.funcname: Optional[str] = None
-        self.parent: Optional[FuncTreeNode] = None
+    def __init__(self, event: dict[str, Any] | None = None) -> None:
+        self.filename: str | None = None
+        self.lineno: int | None = None
+        self.is_python: bool | None = False
+        self.funcname: str | None = None
+        self.parent: FuncTreeNode | None = None
         self.children: list[FuncTreeNode] = []
         self.start: float = - (2 ** 64)
         self.end: float = 2 ** 64

{viztracer-1.0.4 → viztracer-1.1.0}/src/viztracer/main.py

@@ -19,7 +19,7 @@ import time
 import types
 import re
 from types import CodeType
-from typing import Any, Optional, Union
+from typing import Any
 
 from . import __version__
 from .code_monkey import CodeMonkey
@@ -31,12 +31,12 @@ from .viztracer import VizTracer
 # For all the procedures in VizUI, return a tuple as the result
 # The first element bool indicates whether the procedure succeeds
 # The second element is the error message if it fails.
-VizProcedureResult = tuple[bool, Optional[str]]
+VizProcedureResult = tuple[bool, str | None]
 
 
 class VizUI:
     def __init__(self) -> None:
-        self.tracer: Optional[VizTracer] = None
+        self.tracer: VizTracer | None = None
         self.parser: argparse.ArgumentParser = self.create_parser()
         self.verbose: int = 1
         self.ofile: str = "result.json"
@@ -199,7 +199,7 @@ class VizUI:
     def parse(self, argv: list[str]) -> VizProcedureResult:
         # If -- or --run exists, all the commands after --/--run are the commands we need to run
         # We need to filter those out, they might conflict with our arguments
-        idx: Optional[int] = None
+        idx: int | None = None
         if "--" in argv[1:]:
             idx = argv.index("--")
         elif "--run" in argv[1:]:
@@ -295,7 +295,7 @@ class VizUI:
 
         return True, None
 
-    def search_file(self, file_name: str) -> Optional[str]:
+    def search_file(self, file_name: str) -> str | None:
         if os.path.isfile(file_name):
             return file_name
 
@@ -326,7 +326,7 @@ class VizUI:
             return self.uninstall()
         elif self.options.cmd_string is not None:
             return self.run_string()
-        elif self.options.module:
+        elif self.options.module is not None:
             return self.run_module()
         elif self.command:
             return self.run_command()
@@ -342,7 +342,7 @@ class VizUI:
             self.parser.print_help()
             return True, None
 
-    def run_code(self, code: Union[CodeType, str], global_dict: dict[str, Any]) -> VizProcedureResult:
+    def run_code(self, code: CodeType | str, global_dict: dict[str, Any]) -> VizProcedureResult:
         options = self.options
         self.parent_pid = os.getpid()
 
@@ -386,16 +386,12 @@ class VizUI:
         if not options.log_exit:
             tracer.stop(stop_option="flush_as_finish")
 
-            # Clear to global_dict to release all references.
-            # This is helpful for some deadlock issues.
-            global_dict.clear()
-
         # issue141 - concurrent.future requires a proper release by executing
         # threading._threading_atexits or it will deadlock if not explicitly
         # release the resource in the code
         # Python 3.9+ has this issue
         if threading._threading_atexits:  # type: ignore
-            for atexit_call in threading._threading_atexits:  # type: ignore
+            for atexit_call in reversed(threading._threading_atexits):  # type: ignore
                 atexit_call()
             threading._threading_atexits = []  # type: ignore
 
@@ -526,7 +522,7 @@ class VizUI:
         print(__version__)
         return True, None
 
-    def _check_attach_availability(self) -> tuple[bool, Optional[str]]:
+    def _check_attach_availability(self) -> tuple[bool, str | None]:
         if sys.platform == "win32":
             return False, "VizTracer does not support this feature on Windows"