University:
Boston University
Course:
MET CS 201 | Introduction to Programming
Academic year:

2024
Views:

89

Pages:

20
Author:

hejantsp1bh

Outline       Introduction Profiling Data Structures Syntax Generators Accelerators Profiling  Before making code changes you must profile the code.  We are really bad at guessing how different parts of programs perform!  Ways to profile:  Insert timing statements into your code  Laborious but sometimes useful.  Use profiling tools that can measure:     Function call times Line-by-line execution times Memory consumption CPU hardware utilization Profiling Drawbacks  Your program can take much longer to run when it is being profiled.  It may consume more memory.  A test problem that’s small enough to profile reasonably fast might be too small to reveal performance problems. Python Profiling Tools  The Python Standard Library includes two profilers:  cProfile (use this one!)  profile  Documentation is online.  These are deterministic tools that produce statistics about your program.  Deterministic profiling:  All function calls are monitored and timed.  Statistical profiling:  The program is periodically paused and checked to see what it is doing. Additional Profiling Tools  The python3 modules on the SCC offer some additional profilers:  line_profiler  Line-by-line timing statistics for selected functions.  Provided for modules:  python3/3.6.5  python3/3.6.9  memory_profiler  Line-by-line memory usage statistics for selected functions.  For all python3 modules. A simple sample code  Open row_vs_col_orig.py  This does a simple calculation where a Numpy matrix (i.e. a 2D table) is multiplied by a constant value.  3 implementations:  Calculate the new matrix values by multiplying the constant against whole rows at a time  …by multiplying against whole columns at a time  …using Numpy’s built-in element-by-element multiplication syntax. Profiling: manual timing  Use the Python time library: https://docs.python.org/3.6/library/time.html  Next, open row_vs_col_timing.py  This does manual timing of the function calls.  Which version is the fastest?  Change the size of the matrix – does this change your result?  Two easy functions:  time.perf_counter():  Returns a floating point value representing a time.  time.time():  Floating point value of seconds since Jan. 1, 1970, 00:00:00 Better Manual Profiling  Open row_vs_col_decorator.py  Syntax for using a function decorator:  This uses a function decorator to automatically time a function call.  Decorators are functions that intercept arguments to and results from other functions. @decorator def my_func(x,y,z): ... ... Profiling: Using the Python Profiler  Return to row_vs_col_orig.py  Spyder can run the Python profiler for you.  Choose the menu option RunProfile Spyder Profiling Output  Profiler output shows total time spent in each function.  If functions call functions those calls can be shown as well – click the triangles to expand the results. Command Line Python Profiling  Command line profiling results are printed to the screen or can be saved to a file.  Syntax: python -m cProfile run.py  Sort by statistics: python -m cProfile –s time run.py  This can be done inside of a batch job on the SCC…  Best use – save to a file and use a utility to study the output: python -m cProfile –o prof.out run.py python -m cProfile –o prof.out run.py Python Profiling Tools  The SCC has 2 profiling visualization tools for Python  kcachegrind  (no module load required)  Convert prof.out to the required file format open kcachegrind: pyprof2calltree -i prof.out -o prof.log kcachegrind prof.log  snakeviz  Runs in a browser  To use: module load snakeviz/2.0.1 snakeviz prof.out kcachegrind Choose group by source file Line-by-Line Profiling  The SCC Python 3.6 modules (3.6.5 and 3.6.9) have the line_profiler library installed.  To use:  Decorate functions with @profile  Do this for each function in row_vs_col_orig.py @profile def row_by_row(A,mat): ''' compute mat = A*mat row-by-row ''' ...  The kernprof tool is used to do line-by-line profiling.  A 2nd call to Python will print out the results. Run kernprof kernprof -l –o line.lprof row_vs_col_orig.py python -m line_profiler line.lprof Timer unit: 1e-06 s Total time: 0.204861 s File: row_vs_col_orig.py Function: row_by_row at line 32 Line # Hits Time Per Hit % Time Line Contents ============================================================== 32 @profile 33 def row_by_row(A,x): 34 ''' compute x = A*x row-by-row ''' 35 1 5.0 5.0 0.0 rows = x.shape[0] 36 10001 5605.0 0.6 2.7 for i in range(rows): 37 10000 199251.0 19.9 97.3 x[i,:] = x[i,:] * A 38 1 0.0 0.0 0.0 return x Memory Usage Profiling  The memory_profiler library is used in a similar fashion.  To use:  Decorate functions with @profile @profile def row_by_row(A,mat): ''' compute mat = A*mat row-by-row ''' ...  Run the script with the memory_profiler library.  The output is printed to the screen. python -m memory_profiler row_vs_col_orig.py  Set mat_size = 10000: Filename: row_vs_col_orig.py Line # Mem usage Increment Line Contents ================================================ 40 808.535 MiB 808.535 MiB @profile 41 def col_by_col(A,mat): 42 ''' compute mat = A*mat col_by_col ''' 43 808.535 MiB 0.000 MiB cols = mat.shape[1] 44 808.535 MiB 0.000 MiB for i in range(cols): 45 808.535 MiB 0.000 MiB mat[:,i] = A * mat[:,i] 46 808.535 MiB 0.000 MiB return x Whoa! Filename: row_vs_col_orig.py Line # Mem usage Increment Line Contents ================================================ 48 808.535 MiB 808.535 MiB @profile 49 def built_in(A,mat): 50 ''' A*mat using built-in element-by-element''' 51 1571.477 MiB 762.941 MiB return A * mat 2x memory usage…?  This function is calculating the correct quantity.  The syntax creates a new numpy array to hold the result which is returned.  This is an in-place calculation: def built_in(A,mat): return A * mat mat = built_in(scaling_value, mat) def row_by_row(A,mat): rows = mat.shape[0] for i in range(rows): mat[i,:] = A * mat[i,:] return x Fix and re-profile the results.  Memory usage is down: def built_in(A,mat): mat[:] = A * mat return mat Line # Mem usage Increment Line Contents ================================================ 46 808.543 MiB 808.543 MiB @profile 47 def built_in(A,mat): 48 808.543 MiB 0.000 MiB mat[:] = A * mat 49 808.543 MiB 0.000 MiB return mat  Using the profiling in Spyder (remove the @profile): Function row_by_row col_by_col Time (msec) 183.57 2870 built_in (original version) 576.27 built_in (in-place version) 764.87 What do you want to optimize for? Profiling process  Start with function-level profiling:  Spyder profiling  cProfile and kcachegrind  Or snakeviz if you prefer  Identify problem functions.  LEARN THE TOOLS.  Read the docs!  Line profiler is slower than function timing so use where needed.  Use memory profiling when it seems necessary.  Excess memory usage  Uncertain cause for. performance problems.