1

So, I've a GUI that basically allows the user to iteratively process data. Thus, there is a start/stop button and a display that shows the current state of the data. When you click the start button, the callback function calls the data processing function shown below:

function result = process_data(data)
    result = 0;
    for big_loop=big_start:big_end
        for small_loop=small_start:small_end
            result = result+data; %in reality just some fancier matrix ops
        end
    end

My problem is how to implement the stop button's callback so that it returns from process_data after the current iteration of the small loop.

Right now I do this by modifying the process_data code to be as follows:

    function result = process_data_new(data)
        result = 0;
        for big_loop=big_start:big_end
            for small_loop=small_start:small_end
                result = result+data; %in reality just some fancier matrix ops
%new code start -----------------
                if interrupt_flag
                    return;
                end
%new code end -------------------- 
            end
        end

However, I really want the interruption to be handled from the GUI's end so my code isn't littered with interrupt checks (My real code would involve this kind of thing very often, and the user would sometimes need to change the process_data function).

Is this possible? I imagine it would involve making all of the looping variables 'observable' properties, and then waiting for small_loop to change, but I can't figure out details of how to go about implementing the callback.

zergylord
  • 4,368
  • 5
  • 38
  • 60
  • Here's a fleshed out version of the solution I have in mind: make small_loop an observable property, and then create a handler for it (called whenever the value changes). This handler would just look for the interrupt_flag, and if true, then It'd kill/return the process_data function. That last bit is the part that I'm not sure about... – zergylord Sep 22 '11 at 21:45
  • Also, a partial solution would be a way to make pressing stop cause the computation to hang until the start button is pressed again. – zergylord Sep 22 '11 at 21:54

3 Answers3

2

may be this helps:

have a button 'stop', in its callback, set a flag to true.

in the smaller loop (i.e. the other callback which busy in a loop), it will check this flag at the top (or bottom) of its (small) loop.

If the flag is set true, it makes it false right away and terminate the overall loop and returns. (add a check in your loop to check if this flag is set)

So, the most the user has to wait after hitting STOP is for one smaller iteration to complete if the hit happened just after the last check.

callbacks interrupt each others, so the above works.

The flag is set in userData buffer and read from there by the other callback each time.

This snippets code from one example I have

the small loop example

 function status= output(t,x,~,data)
         %called by ode45 after each step. Plot the current
         %pendulum position for simulation

         userData = get(data.handles.figure1, 'UserData');
         if userData.stop
             status=true;
             g_status =true;
         else
             status = false;
             .... do real work
         end
     end

the 'run' button callback

% --- Executes on button press in run_btn.
function run_btn_Callback(hObject, eventdata, handles)
% hObject    handle to run_btn (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

[data,status] = parse_input(handles);
if not(status)
     return;
end
.....
userData.stop = false;
set(handles.figure1, 'UserData',userData);
...

stop button callback

% --- Executes on button press in reset_tag.
function reset_tag_Callback(hObject, eventdata, handles)
% hObject    handle to reset_tag (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


data = get(handles.figure1, 'UserData');
data.stop = true;
set(handles.figure1, 'UserData',data);
.....
Nasser
  • 12,849
  • 6
  • 52
  • 104
  • Wow, thanks for the help. I'll try it out and let you know how it works – zergylord Sep 22 '11 at 22:50
  • Hmmm, unfortunately this appears to be an elaboration on the 'solution' I mentioned in my question. It should work, but ideally I'd want there to be no extra code in the process_data function. Would that be possible? – zergylord Sep 22 '11 at 22:59
  • 2
    You only have to add ONE extra check in the loop. I do not know how to do it by adding no code. I can't do magic :) – Nasser Sep 22 '11 at 23:40
0

If you have the parallel computing toolbox, then you can create a Task.

Otherwise, I don't think it's possible without adding the control flow you suggest since there's no other way of creating a processing thread and stopping it from your UI.

Nzbuu
  • 5,241
  • 1
  • 29
  • 51
  • I don't think you'd need the parallel computing toolbox, seeing as GUI callback functions already intercept control from other processing when they're triggered. Can anyone else confirm/deny this? – zergylord Sep 22 '11 at 21:24
  • 1
    You can't control the calculation threads without PCT. The GUI callbacks do interrupt the processing, but you can't programmatically stop the thread you've just interrupted. Even if you throw an error, it'll terminate the callback and resume what it was doing. – Nzbuu Sep 23 '11 at 09:03
0

what you basically want is to kill the process_data once the user presses the 'stop' button. Unfortunately, this is not possible because there are no real threads in matlab. Therefore, your only solution is the one you've implemented yourself.

memyself
  • 11,907
  • 14
  • 61
  • 102