Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/junolab/devtools.jl
Julia DevTools
https://github.com/junolab/devtools.jl
Last synced: 15 days ago
JSON representation
Julia DevTools
- Host: GitHub
- URL: https://github.com/junolab/devtools.jl
- Owner: JunoLab
- License: other
- Created: 2015-03-21T11:21:03.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2018-04-25T15:47:11.000Z (over 6 years ago)
- Last Synced: 2024-03-26T00:09:56.837Z (8 months ago)
- Language: Julia
- Size: 419 KB
- Stars: 25
- Watchers: 3
- Forks: 11
- Open Issues: 3
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
# DevTools
DevTools.jl provides a couple of useful graphical tools for working with Julia, built on top of [Blink.jl](https://github.com/JunoLab/Blink.jl).
```julia
Pkg.add("Blink")
Pkg.clone("https://github.com/JunoLab/DevTools.jl")
using DevTools
```
## Graphical Display
DevTools hooks into [Media.jl](https://github.com/JunoLab/Media.jl) to provide a graphical display for Julia types. Once DevTools, is loaded, plotting with [Gadfly](https://github.com/dcjones/Gadfly.jl) will open windows like this:
```julia
julia> using DevTools, Gadfly
julia> plot(x=1:100, y=cumsum(randn(100)))
```
There are a few utility functions that you can use to control this output, e.g. `pin()` will prevent new windows from being created (new plots will reuse an old window instead), and `top()` will set the last window to be always on top.
## The Profiler
Let's borrow an example from the excellent [ProfilerView.jl](https://github.com/timholy/ProfileView.jl).
```julia
# profile.jl
function profile_test(n)
for i = 1:n
A = randn(100,100,20)
m = maximum(A)
Afft = fft(A)
Am = mapslices(sum, A, 2)
B = A[:,:,5]
Bsort = mapslices(sort, B, 1)
b = rand(100)
C = B.*b
end
end
profile_test(10) # run once to trigger compilation
Profile.clear() # in case we have any previous profiling data
@profile profile_test(100)
```
With this saved in a file, execute:
```julia
julia> include("profile.jl")
julia> using DevTools
julia> profiler()
```
This will result in an open window which looks something like the following:
This plot represents your program, with each green cell being a line within a given function – hover over to see which. If a line in the program calls some function `f`, then lines from `f` will be displayed directly below the original line, scaled by the amount of time that they took. For example, the top line in this plot is part of the profiler itself, and the largest line below it comes from `profile.jl:6`, followed by `abstractarray.jl:1238` as shown above – this gives a pretty clear idea of where you should aim optimisations.
If you're interested in looking more deeply into Julia's libraries, you can zoom into the plot by scrolling and pan by dragging.
This is certainly nicer than working with a text dump, but there's actually an even better way. Clicking on the `profile.jl:6` cell opens up a view on that line:
This view immediately makes it clear where time is being spent in the program, without having to mentally map between profile output and code. This more flat view can also be convenient for the way it aggregates time taken over the entire run of the program.