cpu usagelinuxunixuptime
If I run uptime, I get something like this:
10:50:30 up 366 days, 23:27, 1 user, load average: 1.27, 2.06, 1.54
What do those numbers on the end mean? The man page tells me it's "the load average of the system over the last 1, 5, and 15 minutes.". But what is the scale? Is 1.27 high? Low? Does it depend on my system?
The load is the average number of runnable processes. man 3 getloadavg says:
The getloadavg() function returns the number of processes in the system run queue averaged over various periods of time. Up to nelem samples are retrieved and assigned to successive elements of loadavg[].
The system imposes a maximum of 3 samples, representing averages over the last 1, 5, and 15 minutes, respectively.
You can also obtain the same information by running sysctl vm.loadavg.
Assuming Mac OS X 10.7.2, the getloadavg function calls this code here (search for the second occurrence of sysctl_loadavg), which, in essence, returns the current value of averunnable.
This, in turn, is defined here:
struct loadavg averunnable =
{ {0, 0, 0}, FSCALE }; /* load average, of runnable procs */
This file also defines compute_averunnable, which computes the new weighted value of averunnable.
The scheduler header file sched.h declares it as extern, and all scheduler implementations in xnu-1699.24.8/osfmk/kern/sched_*.c periodically call it via compute_averages in sched_average.c.
The argument to compute_averunnable, is sched_nrun in sched_average.c, getting its value from sched_run_count in sched.h.
This number is modified by the macros sched_run_incr and sched_run_decr, used exclusively in the file sched_prim.c, which are the scheduling primitives responsible for unblocking, dispatching, etc. of threads.
So, to recap:
It simply uses the number of runnable threads to compute load averages in 5 second intervals.
While the systems are totally different, I find it hard to believe that Linux always has lower loads than OS X. In fact, it appears that Linux simply shows a different value.
Quoting Wikipedia:
On modern UNIX systems, the treatment of threading with respect to load averages varies. Some systems treat threads as processes for the purposes of load average calculation: each thread waiting to run will add 1 to the load. However, other systems, especially systems implementing so-called N:M threading, use different strategies, such as counting the process exactly once for the purpose of load (regardless of the number of threads), or counting only threads currently exposed by the user-thread scheduler to the kernel, which may depend on the level of concurrency set on the process.
Judging from this article, Linux really uses the number of processes that are runnable as opposed to XNU's threads.
Since every runnable process has at least one runnable thread, the load average values on OS X will, assuming an equivalent load average calculation (which I didn't bother to check), always be at least as big, since the item counts they're based on are different.
Understanding Load Average: 0.83 0.73, 0.55
Load is the measure of the amount of computational work a system performs. The three values is the load average over a time interval. The intervals are, the last 1 minute, 5 minutes, and 15 minutes. Load average is computed as an exponential moving average. If you wish, you can take a deep dive and read Examining Load Average
Single Core System
0.83 means your CPU was at 83% capacity within the last minute. A value of 1.0 would mean your CPU is at exact capacity (100%). With the value 1.0 the system will be overloaded by adding even a little bit of additional work. A value greater than 1.0 means it's getting more than it can handle. This isn't bad, it just means that more processes are waiting for CPU time. You would see the slowness of the computer. Multi-Core System
0.83 and having 4 cores, you would take 0.83 / 4 to get 0.2075 or (0.83 / 4) * 100 to get 20.75% capacity. With a quad-core system, if you had a load average greater than 4.0 that would indicate all cores are at 100% capacity, and any overload will result in processes waiting for CPU time.Overloading occurs when you go over your max capacity. The load average as an overload can be a bit confusing to read because it's based on your cores. If you have a quad-core CPU, you won't overload until the load value is over 4.0. If the first load average value was 5.50 that would mean your system is 150% overloaded, and on average 1.5 processes in the last minute had to wait for CPU time.
Understanding %Cpu(s): 0.8us, 0.8sy....
This section is a displays HOW the CPU has been used. Each suffix stands for something specific, and indicates how much time the CPU spent on that set of tasks. If you add up all of the numbers in that output row, it will add up to 100%.
The tasks are defined as... source
Best Answer
Load average is a gauge of how many processes are on average, concurrently demanding CPU attention.
Generally, if you have one process running at 100%, and it just sits like that for all eternity, you can expect all values to approach '1'.
Generally, this is as efficient computing as you can get, no losses due to context-switches.
However, on modern multitasking OS's, there is more than one thing that needs CPU attention, so under a moderate amount of load from a single process, load average should float between 0.8 and 2.
If you decide to do something insane, like build a kernel with
make -j 60, despite only having one logical processor, then load average would rush towards 60, and your computer would be incredibly useless to you (death by context switch).Also to note, this metric is irrespective of how many cores/CPUs there are. For a two-cored system, running one process that consumes a whole core (leaving the other idle) results in a load average of 1.0. In order to decide how loaded a system is, you'll need to know the number of cores and do the division yourself.