11.10.6 Function Locking

It is sometime desirable to lock a function into memory with the mlock function. This is typically used for dynamically linked functions in oct-files or mex-files that contain some initialization, and it is desirable that calling clear does not remove this initialization.

As an example,

function my_function ()
  mlock ();
  …
endfunction

prevents my_function from being removed from memory after it is called, even if clear is called. It is possible to determine if a function is locked into memory with the mislocked, and to unlock a function with munlock, which the following code illustrates.

my_function ();
mislocked ("my_function")
⇒ ans = 1
munlock ("my_function");
mislocked ("my_function")
⇒ ans = 0

A common use of mlock is to prevent persistent variables from being removed from memory, as the following example shows:

function count_calls ()
  mlock ();
  persistent calls = 0;
  printf ("count_calls() has been called %d times\n", ++calls);
endfunction

count_calls ();
-| count_calls() has been called 1 times

clear count_calls
count_calls ();
-| count_calls() has been called 2 times

mlock might also be used to prevent changes to an m-file, such as in an external editor, from having any effect in the current Octave session; A similar effect can be had with the ignore_function_time_stamp function.

: mlock () ¶

Lock the current function into memory so that it can’t be removed with clear.

See also: munlock, mislocked, persistent, clear.

: munlock () ¶

: munlock (fcn) ¶

Unlock the named function fcn so that it may be removed from memory with clear.

If no function is named then unlock the current function.

See also: mlock, mislocked, persistent, clear.

: tf = mislocked () ¶

: tf = mislocked (fcn) ¶

Return true if the named function fcn is locked in memory.

If no function is named then return true if the current function is locked.

See also: mlock, munlock, persistent, clear.