Updated (2020-05-17): Added 2020 training dates.
I will run my Oracle/SQL/Linux tuning & troubleshooting training again in 2020, see more details here:
- Advanced Oracle SQL Tuning training - June 2020
- Practical Linux Performance & Application troubleshooting training - September 2020
- Advanced Oracle Troubleshooting training - TBD (end of 2020 or early 2021)
After a class, the attendees will get downloadable video recordings for their own personal use.
Here are some example slides from the AST class for eye-candy :)
|Execution plan data flow||Reading SQL Monitoring reports|
More Details & what’s coming
I’ve been trying to avoid traveling for a while (as it takes lots of time & energy that could be used elsewhere) and I finally got to a point where I don’t have any upcoming flights in my calendar! I plan to keep it so until the next year… well, maybe there will be one ski trip, but I’ll be drinking beer from the moment I get to the airport :)
I’ll use all this free time for research & development. I have been thinking about an idea of universal approach for application performance diagnosis and troubleshooting & reliability management. Something that could be used on any application, even if the application code can’t be changed. I’m not talking only about Oracle or just database engines here either, although this method can sure be applied to Oracle too. After all, the Oracle RDBMS is just another application that has to conform to the OS and hardware way of running things. But more about this in the future - first, some thinking is needed!
Anyway, as part of geeking out I’ll also update my training material to latest and run a few more classes in the next 6 months, including a completely new one. All around performance & troubleshooting topics of course.
Oracle performance & troubleshooting classes
In addition to my Advanced Oracle Troubleshooting training that I’ll be doing one more time (thanks to all the people who kept asking about it!) I will also deliver my Advanced Oracle SQL Tuning training! I delivered it a number of times between year 2009 and 2013. The last run was done on Oracle 11.2, but now I see a good opportunity to update the material to also cover Oracle 12.2 to Oracle 19c (with lots of new features and lots of new adaptive stuff that sometimes works! :-)
OS & distributed systems research
Also, building the high-performance data virtualization layer for relational databases at Gluent requires me to go very deep into system performance and troubleshooting of complex distributed applications. I’m talking about various Hadoop components and Apache Spark running on Linux. Most of the Hadoop stuff runs in Java Virtual Machines, but for performance & latency reasons some projects have also chosen C++ (Apache Impala SQL engine is using C++ & LLVM for performance sensitive components doing tight loops and Gluent’s Smart Connector is all C++ for similar reasons).
In addition to the constant Oracle database fun I’m having, troubleshooting & optimizing such variety of platforms and components has reminded me that at low level, all applications work the same way - they run on CPU, get put to sleep by OS when waiting for some event to complete (IO) and sometimes voluntarily go to sleep when coordinating work with other parts of the app. Also, the Linux performance diagnosis & troubleshooting toolset is pretty awesome nowadays, so you don’t have to view OS & application problems through a keyhole these days.
Linux performance & troubleshooting class
I will combine the modern Linux performance tools with the method & techniques that I regularly use into a new practical Linux Performance & Application Troubleshooting training! I will open source a new Linux performance tool that I’ve been preparing in the coming months too ;-)
The emphasis of this Linux class is on practical techniques, using scripts and tools that you can use on any Linux machine whenever a problem happens, without having to first install a complex layer of monitoring tools. At the same time, we will go way beyond what the classic OS tools (like
top) have to offer. We will use a process/thread-level approach instead of system wide averages and drill down into application activity from there.
As you noticed, there’s “application troubleshooting” in this class title too - in addition to Linux OS, we are going to spend lots of time troubleshooting Linux-based applications (Java apps, database engines, web servers etc.) with OS tools. This is useful for augmenting the application’s built in instrumentation and logging, or in cases where the app doesn’t have decent logging enabled at all.
While we won’t be spending time on non-practical tasks like recompiling Linux kernels, we sure are going to be using Linux process diagnosis and built-in kernel tracing facilities, starting from
My favorite starting point, however, is to examine the process state from
/proc filesystem directly if the traditional tools are not enough. We’ll be using this technique in the class too. Here’s a blog entry of mine from past that illustrates how useful this simple and non-intrusive technique can be:
- https://tanelpoder.com/psnapper (My new Linux Process Snapper tool)
I hope you’ll find some of this stuff interesting and “See” you soon :-)