The fifth “word I do not use” is the Oracle technical term wait
The Oracle Wait Interface
In 1991, Oracle Corporation released some of the most important software instrumentation of all time: the “wait” statistics that were implemented in Oracle 7.0. Here’s part of the story, in Juan Loaiza
’s words, as told in Nørgaard et. al (2004), Oracle Insights: Tales of the Oak Table
This stuff was developed because we were running a benchmark that we could not get to perform. We had spent several weeks trying to figure out what was happening with no success. The symptoms were clear—the system was mostly idle—we just couldn’t figure out why.
We looked at the statistics and ratios and kept coming up with theories, the trouble was that none of them were right. So we wasted weeks tuning and fixing things that were not the problem. Finally we ran out of ideas and were forced to go back and instrument the code to figure out what the problem was.
Once the waits were instrumented the problem was diagnosed in minutes. We were having “free buffer” waits because the DBWR was not writing blocks fast enough. It’s amazing how hard that was to figure out with statistics, and how easy it was to figure out once the waits were instrumented.
...In retrospect a lot of the names could be greatly improved. The wait interface was added after the freeze date as a “stealth” project so it did not get as well thought through as it should have. Like I said, we were just trying to solve a problem in the course of a benchmark. The trouble is that so many people use this stuff now that if you change the names it will break all sorts of thing tools, so we have to leave them alone.
Before Juan’s team added this code, the Oracle kernel would show you only how much time its user
calls (like parse
, and fetch
) were taking. The new instrumentation, which included a set of new fixed views like v$session_wait
WAIT lines in our trace files
, showed how much time Oracle’s system calls (like reads, writes, and semops)
The Working-Waiting Model
The wait interface begat a whole new mental model about Oracle performance, based on the principle of working versus waiting
Response Time = Service Time + Wait Time
In this formula, Oracle defines service time
as the duration of the CPU used by your Oracle session (the duration Oracle spent working
), and wait time
as the sum of the durations of your Oracle wait events (the duration that Oracle spent waiting
). Of course, response time
in this formula means the duration spent inside the Oracle Database kernel.
Why I Don’t Say Wait, Part 1
There are two reasons I don’t use the word wait
. The first is simply that it’s ambiguous.
The Oracle formula is okay for talking about database time, but the scope of my attention is almost never just Oracle’s response time—I’m interested in the business’s
response time. And when you think about the whole stack (which, of course you do; see holistic
), there are events we could call wait events
all the way up and down:
- The customer waits for an answer from a user.
- The user waits for a screen from the browser.
- The browser waits for an HTML page from the application server.
- The application server waits for a database call from the Oracle kernel.
- The Oracle kernel waits for a system call from the operating system.
- The operating system’s I/O request waits to clear the device’s queue before receiving service.
If I say waits
, the users in the room will think I’m talking about application response time, the Oracle people will think I’m talking about Oracle system calls, and the hardware people will think I’m talking about device queueing delays. Even when I’m not.
Why I Don’t Say Wait, Part 2
There is a deeper problem with wait
than just ambiguity, though. The word wait
invites a mental model that actually obscures your thinking about performance
Here’s the problem: waiting
sounds like something you’d want to avoid, and working
sounds like something you’d want more of. Your program is waiting
?! Unacceptable. You want it to be working
. The connotations of the words working
are unavoidable. It sounds like, if a program is waiting a lot, then you need to fix it; but if it’s working a lot, then it is probably okay. Right?
The connotations “work is virtuous” and “waits are abhorrent” are false
connotations in Oracle. One is not inherently better or worse than the other. Working
are not accurate value judgments about Oracle software. On the contrary, they’re not even meaningful
; they’re just arbitrary labels. We could just as well have been taught to say that an Oracle program is “working on disk I/O” and “waiting to finish its CPU instructions.”
The terms working
really just refer to different subroutine call types:
|“Oracle is working”||means||“your Oracle kernel process is executing a user call”|
|“Oracle is waiting”||means||“your Oracle kernel process is executing a system call”|
The working-waiting model implies a distinction that does not exist, because these two call types have equal footing. One is no worse than the other, except by virtue of how much time it consumes. It doesn’t matter whether a program is working or waiting; it only matters how long it takes.
Working-Waiting Is a Flawed Analogy
The working-waiting paradigm is a flawed analogy. I’ll illustrate. Imagine two programs that consume 100 seconds apiece when you run them:
|Program A||Program B|
|Duration||Call type||Duration||Call type|
|98||system calls (waiting)||98||user calls (working)|
|2||user calls (working)||2||system calls (waiting)|
To improve program A, you should seek to eliminate unnecessary system calls, because that’s where most of A’s time has gone. To improve B, you should seek to eliminate unnecessary user calls
, because that’s where most of B’s time has gone. That’s it. Your diagnostic priority shouldn’t be based on your calls’ names; it should be based solely on your calls’ contributions to total duration. Specifically, conclusions like, “Program B is okay because it doesn’t spend much time waiting,” are false.
A Better Model
I find that discarding the working-waiting model helps people optimize better. Here’s how you can do it. First, understand the substitute phrasing: working
means executing a user
call; and waiting
means executing a system
call. Second, understand that the excellent ideas people use to optimize other software are excellent ideas for optimizing Oracle, too:
- Any program’s duration is a function of all of its subroutine call durations (both user calls and system calls), and
- A program is running as fast as possible only when (1) its unnecessary calls have been eliminated, and (2) its necessary calls are running at hardware speed.
Oracle’s wait interface is vital because it helps us measure an Oracle program’s complete
execution duration—not just Oracle’s user
calls, but its system
calls as well. But I avoid saying wait
to help people steer clear of the incorrect bias introduced by the working-waiting analogy.