BogoMips

BogoMips (from "bogus" and MIPS) is a crude measurement of CPU speed made by the Linux kernel when it boots to calibrate an internal busy-loop. An often-quoted definition of the term is "the number of million times per second a processor can do absolutely nothing".
BogoMips is a value that can be used to verify whether the processor in question is in the proper range of similar processors, i.e. BogoMips represents a processor's clock frequency as well as the potentially present CPU cache. It is not usable for performance comparisons among different CPUs.
History.
In 1993, Lars Wirzenius posted a Usenet message explaining the reasons for its introduction in the Linux kernel on comp.os.linux:
Proper BogoMips ratings.
As a very approximate guide, the BogoMips can be pre-calculated by the following table. The given rating is typical for that CPU with the then current and applicable Linux version. The index is the ratio of "BogoMips per clock speed" for any CPU to the same for an Intel 386DX CPU, for comparison purposes.
With the 2.2.14 Linux kernel, a caching setting of the CPU state was moved from behind to before the BogoMips calculation. Although the BogoMips algorithm itself wasn't changed, from that kernel onward the BogoMips rating for then current Pentium CPUs was twice that of the rating before the change. The changed BogoMips outcome had no effect on real processor performance.
In Linux, BogoMips can be easily obtained by searching the cpuinfo file:
$ grep -i bogomips /proc/cpuinfo
Computation of BogoMIPS.
With kernel 2.6.x, BogoMIPS are implemented in the codice_1 kernel source file. It computes the Linux kernel timing parameter codice_2 (see jiffy) value. The explanation from source code:
codice_2 is used to implement codice_4 (delay in microseconds) and codice_5 (delay in nanoseconds) functions. These functions are needed by some drivers to wait for hardware. Note that a busy waiting technique is used, so the kernel is effectively blocked when executing codice_5/codice_4 functions. For i386 architecture codice_8 is implemented in codice_9 as:
/* simple loop based delay: */
static void delay_loop(unsigned long loops)
 int d0;
 __asm__ __volatile__(
 "\tjmp 1f\n"
 ".align 16\n"
 "1:\tjmp 2f\n"
 ".align 16\n"
 "2:\tdecl %0\n\tjns 2b"
 :"=&a" (d0)
 :"0" (loops));
equivalent to the following assembler code
 jmp start
.align 16
start: jmp body
.align 16
body: decl eax
 jns body
which can be rewritten to C-pseudocode
static void delay_loop(long loops)
 long d0 = loops;
 do {
 --d0;
 } while (d0 >= 0);
Full and complete information and details about BogoMips, and hundreds of reference entries can be found in the (outdated) BogoMips mini-Howto.
Timer-based delays.
In 2012, ARM contributed a new codice_4 implementation allowing the system timer built into many ARMv7 CPUs to be used instead of a busy-wait loop. This implementation was released in Version 3.6 of the Linux kernel. Timer-based delays are more robust on systems that use frequency scaling to dynamically adjust the processor's speed at runtime, as codice_11 values may not necessarily scale linearly. Also, since the timer frequency is known in advance, no calibration is needed at boot time.
One side effect of this change is that the BogoMIPS value will reflect the timer frequency, not the CPU's core frequency. Typically the timer frequency is much lower than the processor's maximum frequency, and some users may be surprised to see an unusually low BogoMIPS value when comparing against systems that use traditional busy-wait loops.