Hi all,
Over the past few years, we’ve been building runtime analysis tools for different languages and use cases, including Julia. Today, we would like to officially announce the release of our Julia profiling toolbox: CodeGlass for Julia.
With CodeGlass we try to make profiling and finding issues as easy as possible. We do this by combining all the data in one central place and showing this in a visual and clicky way.
CodeGlass collects everything that happens in your application in real-time. This allows you to see exactly what your code is doing, as it is happening. No changes needed.
Features
CodeGlass comes with a lot of features; some are generic between our language implementations, but some are also Julia specific. A full list of all features and views can be found here on our docs. Some of our most important features are:
Code Statistics
Information such as durations, call count but also memory usage across all modules and functions used in your application.
Memory Statistics
Information such as allocations, deallocations and which function allocates them.
Runtime Function Information
Runtime information about how functions behaved and got called (multiple and dynamic dispatch behavior) to give you up to the line of code information of your functions.
Recordings
Focus on specific parts of your program, by recording parts of execution without needing to restart or modify it, and directly compare recordings to identify differences.
Garbage Collections
Full garbage collection information such as each object that got deallocated and which function originally allocated that object.
Why CodeGlass
Understanding performance or memory issues in Julia often means isolating parts of your application, turning them into a minimum working example, and running them repeatedly with different tools.
This is time-consuming, and it often does not reflect what actually happens in the full application. Some issues only show up during real runs and disappear once the code is isolated.
With CodeGlass you don’t have to change your application, just run it like you are used to and see exactly what is happening during execution. And it is tracing in real-time, not sampling. This allows you to drill down to the root cause of your issue, whether that is performance, memory or GC related.
Getting started
You can download CodeGlass from our GitHub page. Our documentation explains how to get it up and running quickly. Although CodeGlass is not a free product, but we do offer a 14-day trial license so you can explore it freely (without entering any payment information
).
We would love your feedback. Feel free to ask questions here or reach out to us directly.
FAQ
Who are we?
We are a developer driven company that helps software developers by providing specialized development tools for various languages and use cases. So far, this community has been very welcoming to us, but doing B2C instead of B2B is still new for us, on the product side but company side as well. This is something we will have to grow into, and we hope you will help us to do so!
Meet myself and the team, from left to right, back to front:
How does this work?
Julia already gives users and package developers quite a bit of information to build tools and get insight into what your application does. But this was not enough for us to get the level of detail we wanted. To solve this, we build our own instrumentation layer directly into Julia. For now, this means that you will have to use the Julia version that we ship with your CodeGlass installation (which is v1.12.6 at the moment). Once we are closer to finalizing our instrumentation spec, we will look into upstreaming these changes.
Why not open source?
We have seen that many tools in Julia are open source, and that this is something important within the community. But open sourcing CodeGlass would also mean that we would need to make our other tools available, which we cannot do right now due to agreements we made with other parties.
However, we will look into upstreaming our instrumentation layer so others can make tools on this as well.
Performance impact?
CodeGlass collects all required data by tracing your application. This will of course have an impact on the application’s performance. By configuring what you want to collect, this overhead can range from 2x up to 20x slower, but in most cases, you should expect around 5x. The timings shown in CodeGlass have this overhead removed, so your application’s statistics closely reflect the actual execution time.
What is on the roadmap?
This release is only the first of many. With each update we hope to include many new features to make it easier to solve your problems with your Julia application. If you have any features you would like to see in CodeGlass, please join our Discord and let us know. We cannot guarantee that we will include this in the next version, but your feedback is valuable to us, so please let us know.
For now, we have the following list of features on our roadmap (in no particular order):
- Stepping functionalities, allowing you to replay parts of your application
- Integration with Visual Studio Code
- Systems to make updating CodeGlass and CodeGlass Julia easier, e.g. using Juliaup for distributing our Julia versions.
- More views to help make finding issues easier, e.g. flame graphs
- Improved garbage collection overview
- .NET language support
What are caveats?
One thing we should mention is that CodeGlass can provide you all the information you need, but it will also give you all the information you don’t need. For example, when you run your application, it will not only collect information about your code but also about all the packages you use. This data is then also visible in CodeGlass, which makes it harder than we’d like to find your data and filter out the rest. That is why we are currently working on views and features that will make this task easier.
Another problem is that we have to add our instrumentation layer directly into Julia. This means that we do not support every Julia version currently. At the moment, we only support the latest (at writing v1.12.6), but we can implement support for older versions if the demand is high enough.
Congrats with your public release 