MATLAB - objects not clearing when timers are involved

Question

This is somewhat related to this question, but not quite.

I have two classes, FunctionWrapper and TimerWrapper:

classdef FunctionWrapper < handle
    methods
        function Fcn(obj)
            disp('FunctionWrapper.Fcn was called!');
        end
    end
end

classdef TimerWrapper < handle
    properties
        Timer
    end

    methods
       function obj = TimerWrapper(other_object)
            obj.Timer = timer;
            set(obj.Timer, 'Period', 1);
            set(obj.Timer, 'ExecutionMode', 'fixedSpacing');
            set(obj.Timer, 'TimerFcn', @(event, data) other_object.Fcn);
       end

       function start(obj)
           start(obj.Timer);
       end

       function stop(obj)
           stop(obj.Timer);
       end

       function delete(obj)
           disp('destructor called!');
           delete(obj.Timer);
       end
    end
end

Say I execute the following code in the Command Window:

>> F = FunctionWrapper;
>> T = TimerWrapper(F);
>> clear T %# T's destructor not called
>> timerfind %# just to verify that no, the destructor was never called

   Timer Object: timer-1

   Timer Settings
      ExecutionMode: fixedSpacing
             Period: 1
           BusyMode: drop
            Running: off

   Callbacks
           TimerFcn: @(event,data)other_object.Fcn
           ErrorFcn: ''
           StartFcn: ''
            StopFcn: ''

What's going on here? I know that timer objects need to be manually deleted, but I thought that would be dealt with in the destructor for TimerWrapper. Without using Amro's ugly but straightforward workaround to overload the clear command, is there a way to clear T from the workspace? Furthermore, nothing is referring to T, so why does a reference to it exist? (The fact that the destructor is never called implies this fact.) Is this buried in the timer object itself?

score 2 · Accepted Answer · edited May 23 '17 at 12:06

If you type t = TimerWrapper; f = functions(t.Timer.TimerFcn); f.workspace(2), you'll see that the workspace of the anonymous function used for the callback contains a reference to the TimerWrapper object itself. So there's a kind of circular reference there which is not picked up by clear.

Given how you've set things up, you can remove T (and its underlying timer object) by calling the destructor explicitly and then calling clear.

T.delete
clear T

The difference between clear and delete is kind of confusing (to me, anyway). As you've found, clear doesn't explicitly call the destructor. It just removes the name T from the workspace. So T, and its underlying timer, still exist at that point. If they contained no references to things that still existed, MATLAB would then remove T properly, including calling its destructor. As it is, since the timer contains a reference (in its callback) to T, which still exists, the timer (and thus T as well) is not deleted.

You can find it (despite not having a name in the workspace) with timerfindall, and if you explicitly delete it yourself using

tmrs = timerfindall;
delete(tmrs);

you'll find that T is now properly gone.

I'm not so sure that this is a bug, although I find it pretty confusing, and the distinction between clear and delete could probably be documented better.

As to a workaround, I don't find it a big pain to explicitly call delete, although it's a bit more of a pain to clean things up if you accidentally call clear. I would think the suggestion in message #5 from the thread you linked to, rather than message #4, would be more general and robust.

I don't think you should overload clear in the way @Amro suggests in the separate thread you linked to: although this may work if you call clear T explicitly, you may still get into trouble if you call clear all, or clear variables. (I haven't tried it just now, but I believe these syntaxes of clear don't even loop over things in the workspace and call clear on each - instead they call the clear method of the internal MATLAB workspace object, and that's going to get confusing fast).

I actually removed the reference to `F` entirely and just used `disp` for the callback to test this out. It still doesn't clear on its own properly. — Dang Khoa, May 08 '12 at 15:15
But if you type T.delete, followed by clear T, that works, right? — Sam Roberts, May 08 '12 at 15:35
Yes, it does. This is the right way to do it, but my code base is huge and my users (actually, most MATLAB users) have no idea that `delete` and `clear` are two different things. Anyhow, I am still trying to understand why having a `TimerFcn` yields this behavior (assuming it's not a bug, which I think it is). — Dang Khoa, May 08 '12 at 15:42
OK - I think I have a clearer explanation. Make a version of `TimerWrapper` that has `@(~,~)disp('hello')` as the `TimerFcn`, and type `t = TimerWrapper`. Now type `f = functions(t.Timer.TimerFcn)` and `f.workspace(2)`. You'll see that the workspace of the anonymous function used for the timer callback contains a reference to the TimerWrapper object itself. So there's a kind of circular reference there (whether or not `F` is referenced), which is not getting picked up by `clear`. — Sam Roberts, May 08 '12 at 16:11
if you edit your answer to include that information, I'll award the checkmark + 50 bounty! — Dang Khoa, May 08 '12 at 18:35
Here's one further idea. Give `TimerWrapper` a static method `fcn = maketimerfcn(obj)`, which defines `fcn` as `@(event,data)obj.Fcn`. Then set the timer's `TimerFcn` o `TimerWrapper.maketimerfcn(other_object)`. Because the anonymous function gets created in a workspace where the main `TimerWrapper` object doesn't exist, there's no circular reference, and the destructor gets called as you want it to. — Sam Roberts, May 09 '12 at 11:38
the minimum bounty I can offer is 100.. I thought it was 50 :( — Dang Khoa, May 10 '12 at 15:10

Dang Khoa · Answer 2 · 2012-05-10T16:06:33.480

0

It seems as though this might be because the timer's callback is set to a non-default value. A proposed workaround (see message#4 of the linked thread) is to set the callback function only when the start method is called, then setting it to null when the stop method is called.

edited May 10 '12 at 16:06

answered May 07 '12 at 22:42

Dang Khoa

5,693
8
51
80

MATLAB - objects not clearing when timers are involved

2 Answers2

Linked