A byte-compiled function is not as efficient as a primitive function written in C, but runs much faster than the version written in Lisp. Here is an example:
(defun silly-loop (n)
"Return time before and after N iterations of a loop."
(let ((t1 (current-time-string)))
(while (> (setq n (- n 1))
0))
(list t1 (current-time-string))))
⇒ silly-loop
(silly-loop 40000000)
⇒ ("Mon May 2 14:02:28 2005"
"Mon May 2 14:02:43 2005") ; 15 seconds
(byte-compile 'silly-loop)
⇒ #<compiled-function
(n)
"...(23)"
[current-time-string t1 n 0]
2
"Return time before and after N iterations of a loop.">
(silly-loop 40000000)
⇒ ("Mon May 2 14:03:24 2005"
"Mon May 2 14:03:29 2005") ; 5 seconds
In this example, the interpreted code required 15 seconds to run, whereas the byte-compiled code required 5 seconds. These results are representative, but actual results will vary greatly.
Now of course, machines get faster, so efficiency differences is not always this drastic.
Just compare to the old example:
(silly-loop 5000000)
⇒ ("Mon Sep 14 15:51:49 1998"
"Mon Sep 14 15:52:07 1998") ; 18 seconds
and evaluation 7 years later:
(silly-loop 5000000)
⇒ ("Fri May 6 12:49:16 2005"
"Fri May 6 12:49:17 2005") ; 1 second
In this particular case, the byte-code version of silly-loop
would not be faster (within the resolution of whole seconds).