scalene
line_profiler
scalene | line_profiler | |
---|---|---|
32 | 17 | |
11,174 | 2,481 | |
1.4% | 1.3% | |
9.2 | 8.2 | |
7 days ago | 5 days ago | |
Python | Python | |
Apache License 2.0 | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
scalene
-
Memray – A Memory Profiler for Python
I collected a list of profilers (also memory profilers, also specifically for Python) here: https://github.com/albertz/wiki/blob/master/profiling.md
Currently I actually need a Python memory profiler, because I want to figure out whether there is some memory leak in my application (PyTorch based training script), and where exactly (in this case, it's not a problem of GPU memory, but CPU memory).
I tried Scalene (https://github.com/plasma-umass/scalene), which seems to be powerful, but somehow the output it gives me is not useful at all? It doesn't really give me a flamegraph, or a list of the top lines with memory allocations, but instead it gives me a listing of all source code lines, and prints some (very sparse) information on each line. So I need to search through that listing now by hand to find the spots? Maybe I just don't know how to use it properly.
I tried Memray, but first ran into an issue (https://github.com/bloomberg/memray/issues/212), but after using some workaround, it worked now. I get a flamegraph out, but it doesn't really seem accurate? After a while, there don't seem to be any new memory allocations at all anymore, and I don't quite trust that this is correct.
There is also Austin (https://github.com/P403n1x87/austin), which I also wanted to try (have not yet).
Somehow this experience so far was very disappointing.
(Side node, I debugged some very strange memory allocation behavior of Python before, where all local variables were kept around after an exception, even though I made sure there is no reference anymore to the exception object, to the traceback, etc, and I even called frame.clear() for all frames to really clear it. It turns out, frame.f_locals will create another copy of all the local variables, and the exception object and all the locals in the other frame still stay alive until you access frame.f_locals again. At that point, it will sync the f_locals again with the real (fast) locals, and then it can finally free everything. It was quite annoying to find the source of this problem and to find workarounds for it. https://github.com/python/cpython/issues/113939)
- Scalene: A high-performance CPU GPU and memory profiler for Python
- Scalene: A high-performance, CPU, GPU, and memory profiler for Python
-
How can I find out why my python is so slow?
Use this my fren: https://github.com/plasma-umass/scalene
-
Making Python 100x faster with less than 100 lines of Rust
You should take a look at Scalene - it's even better.
https://github.com/plasma-umass/scalene
-
Blog Post: Making Python 100x faster with less than 100 lines of Rust
I like seeing another Python profiler. The one I've been playing with is Scalene (GitHub). It does some fun things related to letting you see how much things are moving across the system Python memory boundary.
-
Cum as putea sa imbunatatesc timpul de rulare al pitonului?
Ai vazut "Python Performance Matters" by Emery Berger (Strange Loop 2022)? E in principiu o prezentare si demo cu Scalene.
- Scalene - A Python CPU/GPU/memory profiler with optimization proposals
- Scalene: A Python CPU/GPU/memory profiler with optimization proposals
-
OpenAI might be training its AI technology to replace some software engineers, report says
I tried out some features of machine learning models suggesting optimisations on code profiled by scalene and pretty much all of them would make the code less efficient, both time and memory wise. I am not worried. The devil is in the details and ML will not replace all of us anytime soon
line_profiler
- Ask HN: C/C++ developer wanting to learn efficient Python
- New version of line_profiler: 4.1.0
-
Making Python 100x faster with less than 100 lines of Rust
LineProfiler is the best tool to learn how to write performant Python and code optimization.
https://github.com/pyutils/line_profiler
You can literally see the hot spot of your code, then you can grind different algorithms or change the whole architecture to make it faster.
For example replace short for loops to list comprehensions, vectorize all numpy operations (only vectorize partially do not help the issue), using 'not any()' instead or 'all()' for boolean, etc.
Doing this for like 2 weeks, basically you can automatically recognized most bad code patterns in a glance.
-
Why is my Pubmed plant search app so slow?
You may want to try using a package like line_profiler to narrow down where the time is spent.
-
How to make nested for loops run faster
When tuning for performance, always measure. Never assume you know where the slow parts are. Run a line profiler and see where all the time is actually going.
-
I'm working on a world map generator, but I have one function in particular that is very slow and keeping me from being able to scale my maps to as large as I'd like... is there a way that I can optimize this depth first search function, or another way of grouping contiguous cells based on criteria?
Either way I would highly recommend running a profiler on your code to see where the program is spending most of its time. line_profiler is a very nice one, as it shows you execution time for each line.
-
Is it possible to make a function to check how many lines of code have been executed in the program so far (including said function’s lines)?
There are dedicated tools like line_profiler for python - if this doesn't do exactly what you need it can be easily modified.
-
Why does sklearn.Pipeline with regex outperform spacy for text preprocessing?
It's surprising to me that an sklearn pipeline and a spacy pipeline both doing simple regexing are vastly different in performance. I would go one layer deeper with measurement with something like line_profiler, which I've used to great effect to get line-by-line perf stats. This should illuminate why.
-
Hot profiling for Python
This looks really nice! Does it use line_profiler or is it a different implementation for the profiling? Either way the interface is fantastic!
-
Profiling and Analyzing Performance of Python Programs
# https://github.com/pyutils/line_profiler pip install line_profiler kernprof -l -v some-code.py # This might take a while... Wrote profile results to some-code.py.lprof Timer unit: 1e-06 s Total time: 13.0418 s File: some-code.py Function: exp at line 3 Line # Hits Time Per Hit % Time Line Contents ============================================================== 3 @profile 4 def exp(x): 5 1 4.0 4.0 0.0 getcontext().prec += 2 6 1 0.0 0.0 0.0 i, lasts, s, fact, num = 0, 0, 1, 1, 1 7 5818 4017.0 0.7 0.0 while s != lasts: 8 5817 1569.0 0.3 0.0 lasts = s 9 5817 1837.0 0.3 0.0 i += 1 10 5817 6902.0 1.2 0.1 fact *= i 11 5817 2604.0 0.4 0.0 num *= x 12 5817 13024902.0 2239.1 99.9 s += num / fact 13 1 5.0 5.0 0.0 getcontext().prec -= 2 14 1 2.0 2.0 0.0 return +s
What are some alternatives?
flask-profiler - a flask profiler which watches endpoint calls and tries to make some analysis.
SnakeViz - An in-browser Python profile viewer
palanteer - Visual Python and C++ nanosecond profiler, logger, tests enabler
memory_profiler - Monitor Memory usage of Python code
pytest-austin - Python Performance Testing with Austin
reloadium - Hot Reloading and Profiling for Python
memray - Memray is a memory profiler for Python
pprofile - Line-granularity, thread-aware deterministic and statistic pure-python profiler
pyshader - Write modern GPU shaders in Python!
psutil - Cross-platform lib for process and system monitoring in Python
viztracer - VizTracer is a low-overhead logging/debugging/profiling tool that can trace and visualize your python code execution.
prometeo - An experimental Python-to-C transpiler and domain specific language for embedded high-performance computing