I have several helper functions in my code which get called many times for a given numerical calculation. Those helper functions use some constant values for their calculations. The same constant value might be used by more than one helper function.
This seems like an ideal scenario to define class properties with constant values. However, I have done some benchmark tests and I am quite surprised with the results.
Consider the following class for example (Consts.m):
classdef Consts
properties (Constant)
A = 0.5
B = 3
end
properties
VariableA
VariableB
end
methods
function obj = Consts()
obj.VariableA = 0.5;
obj.VariableB = 3;
end
end
end
And the following file (speed_tests.m):
function speed_tests()
tic;
for i = 1:200000
direct_constant_access(1, 2);
end
fprintf('Direct constant access: ');
toc;
tic;
c = Consts();
for i = 1:200000
passing_extra_obj(1, 2, c);
end
fprintf('Passing extra object: ');
toc;
tic;
for i = 1:200000
persistent_constants(1, 2);
end
fprintf('Persistent constants: ');
toc;
% Let's assume this code is executed at some point externally:
% global A B;
% A = 0.5;
% B = 3;
tic;
for i = 1:200000
defined_globally(1, 2);
end
fprintf('Defined globally: ');
toc;
tic;
for i = 1:200000
hardcoded(1, 2);
end
fprintf('Hardcoded: ');
toc;
tic;
for i = 1:200000
hardcoded_v2(1, 2);
end
fprintf('Hardcoded v2: ');
toc;
end
function val = direct_constant_access(a, b)
val = (a + Consts.A)^2 + log(b * Consts.B);
end
function val = passing_extra_obj(a, b, obj)
val = (a + obj.VariableA)^2 + log(b * obj.VariableB);
end
function val = persistent_constants(a, b)
persistent A B;
if isempty(A)
A = Consts.A^2;
B = Consts.B;
end
val = (a + A)^2 + log(b * B);
end
function val = defined_globally(a, b)
global A B;
val = (a + A)^2 + log(b * B);
end
function val = hardcoded(a, b)
val = (a + 0.5)^2 + log(b * 3);
end
function val = hardcoded_v2(a, b)
A = 0.5;
B = 3;
val = (a + A)^2 + log(b * B);
end
When I run speed_tests() on MATLAB R2010b, this is what I obtain (your mileage may vary):
>> speed_tests()
Direct constant access: Elapsed time is 5.973690 seconds.
Passing extra object: Elapsed time is 1.760897 seconds.
Persistent constants: Elapsed time is 1.594263 seconds.
Defined globally: Elapsed time is 1.559441 seconds.
Hardcoded: Elapsed time is 0.673995 seconds.
Hardcoded v2: Elapsed time is 0.661189 seconds.
Perhaps I am too used to other programming languages (where true constants might simply get replaced by literals at compile time), but is accessing class constants really that slow in MATLAB or am I missing something?
When I try the same in MATLAB R2013a (same computer), this direct constant access seems to have improved quite a lot:
>> speed_tests()
Direct constant access: Elapsed time is 2.168146 seconds.
Passing extra object: Elapsed time is 1.593721 seconds.
Persistent constants: Elapsed time is 2.302785 seconds.
Defined globally: Elapsed time is 1.404252 seconds.
Hardcoded: Elapsed time is 0.531191 seconds.
Hardcoded v2: Elapsed time is 0.493668 seconds.
Still, none of the non-hardcoded versions is anywhere near the hardcoded ones. These are the only two MATLAB versions I have available at work, so I am unaware if this has kept improving over the years (and it wouldn't be relevant for myself, since I wouldn't be able to use newer versions anyway).
The CPU time is quite an important factor for what I am developing, but I would like to avoid filling the code with hardcoded literals if I can. Aren't class constants the alleged way of avoiding this?
Is there anything else that I could consider instead?
Note: the real helper functions get called with different arguments each time, so caching the result does not help in my case.
I've run into this issue as well, if there is a trick to reducing the overhead of accessing class objects I would also love to know.
When I can I try to minimize the number of times the object is accessed. In your example I would access A and B once before starting the loop, and then pass them as arguments to each function call.
function speed_tests()
tic;
A = Consts.A;
B = Consts.B;
for i = 1:200000
passing_arguments(1, 2, A, B);
end
fprintf('Passing arguments: ');
toc;
tic;
for i = 1:200000
persistent_constants(1, 2);
end
fprintf('Persistent constants: ');
toc;
tic;
for i = 1:200000
hardcoded(1, 2);
end
fprintf('Hardcoded: ');
toc;
end
function val = passing_arguments(a, b, A, B)
val = (a + A)^2 + log(b * B);
end
function val = persistent_constants(a, b)
persistent A B;
if isempty(A)
A = Consts.A^2;
B = Consts.B;
end
val = (a + A)^2 + log(b * B);
end
function val = hardcoded(a, b)
val = (a + 0.5)^2 + log(b * 3);
end
Output:
Passing arguments: Elapsed time is 0.035402 seconds.
Persistent constants: Elapsed time is 0.208998 seconds.
Hardcoded: Elapsed time is 0.027781 seconds.