[Gretl-devel] some devel news: using function pointers
Here's something I've been working on lately. tl;dr: gretl has just
become substantially more efficient in respect of basic functions
applied to each element of a big matrix or series. If you'd like the
full story, read on.
By "basic functions" I mean those that take a single floating-point
value as argument and return a floating-point value, such as log,
exp, fabs, all the C-library trigonometric functions, and a bunch of
libgretl functions such as cnorm, dnorm, round, etc.
Suppose you want to apply such functions to a big matrix. You can of
course do that in hansl -- as in "matrix logM = log(M)" for a matrix
M -- but what's going on in the background? (The C library has no
"matrix" type and its log function applies strictly to single
numeric values, with the sole exception of complex numbers if we
consider those pairs as "not single").
We have to do the following (in pseudo-code):
for each element x = M(i,j) of original matrix M
apply function f to x and get result y
set element R(i,j) of result matrix R to y
end
The question is, how do we implement the "apply function f" part?
That is, how is "function f" identified? If it were identified by
name ("log", "sin" and so on) we'd have to look up the function by
name on each iteration of the loop. That's possible under POSIX but
not, in general, on MS Windows (or not without severe contortions),
and it would be horribly inefficient.
Up till now we've identified f using a fixed ID number, associated
with the name of the function via a look-up table. And the inner
"apply" bit included a loop across these IDs. So, for example, if
"log" mapped to ID 287 and "exp" to 288, that loop would include
lines resembling
if (f == 287) return log(x);
if (f == 288) return exp(x);
along with many other clauses of the same sort.
That's much better than look-up by name, but gretl still has to wade
through a bunch of "if (f == ID)" clauses to find what should be
done per element of the matrix (or entry in the series).
Solution: Instead of making "f" a symbolic ID of any sort that has
to be looked up, make it an actual pointer-to-function (the memory
address at which the function can be found). That's what we now do
for such functions.
In my experiments this reduces the time taken for scripts that are
heavy on calls to "basic functions", as defined above, by roughly 25
to 45 percent. Artificial example:
<hansl>
matrix m = muniform(50, 50)
set stopwatch
loop 5000 -q
res = log(m)
res = exp(m)
res = sqrt(m)
endloop
printf "elapsed: %gs\n", $stopwatch
</hansl>
In current git you can turn off the use of function pointers, to
compare with old-style behavior, by commenting out line 1340 of
lib/src/gensyntax.c (with comment "attach function pointer, if
available").
Allin