Why do programs run slower on first run after compile?

Question

I have this simple hello world program:

#include <stdio.h>

int main() {
  printf("Hello, world!\n");
  return 0;
}

I compiled this program with LLVM Clang (v15.0.1, built from Homebrew, so not Apple's version) like normal, then I ran and timed the outputs. To my surprise, the first time the program ran, it took nearly 10x longer than the second time, but the next three executions run much faster.

$ clang test.c -o test
$ time ./test
Hello, world!

real    0m0.169s
user    0m0.001s
sys 0m0.002s
$ time ./test
Hello, world!

real    0m0.017s
user    0m0.001s
sys 0m0.006s
$ time ./test
Hello, world!

real    0m0.004s
user    0m0.001s
sys 0m0.002s
$ time ./test
Hello, world!

real    0m0.008s
user    0m0.001s
sys 0m0.005s

I'm running this on an Intel Core i5 mac, running macOS Big Sur v11.6.8. The shell is the bash shipped with macOS.

Nothing in my code deals with time, and I don't think there's anything to cache, so I'm not sure why the first execution runs so slow. I suspect that the OS might be doing some kind of optimization, but I don't know what/how. What is the cause of this large discrepancy in runtimes?

Answer 1

The behavior you are observing is likely due to the way modern operating systems handle executable files' first-time execution. It's called "file system caching" or "disk caching." When you execute a program for the first time, the operating system loads the program from disk into memory, and subsequent executions are much faster because the OS keeps a cached copy of the program in memory.

Here's what typically happens during the first and subsequent runs:

First Execution:

The operating system loads the executable "test" from disk into memory. The program is executed, and the output is displayed. Since it's the first time running the program, the OS doesn't have a cached copy, and it takes some time to read from the disk and load the program into memory, which leads to a longer execution time. Subsequent Executions:

The operating system already has a cached copy of the "test" program in memory from the first execution. The cached copy is used directly, eliminating the need to read from the disk, resulting in much faster execution times. As you've observed, subsequent executions are significantly faster than the first one. The time difference you see between the first and second execution is likely due to the disk cache and memory cache behavior of the operating system. On subsequent runs, the program's binary and library dependencies may still reside in memory, which makes the execution much faster.

Additionally, the timing differences you see can also be affected by other background processes running on your system during different executions.

This behavior is not specific to macOS; it's a common feature of modern operating systems to improve the overall performance of frequently executed programs.

If you want to get a more consistent benchmark of your program's execution time, you can run it multiple times and take the average time from those runs after the initial cache warm-up.