How to execute a function called many times, only once !

Question

Hello,

is there a way to execute a function that is called thousand of times only once ? I have a function that adds items in a container of sort, and there is code in there, that updates lists and other windows (GUI staff). So, if i have to add a million items (the number of which is impossible to tell, anyone could call the function from anywhere), the GUI update mechanism will be called as many as times... Is there a way to tell appart continuous function execution (and ignore it) from discontinuous ? Is there a safe way to execute the update mechanism only the last time the add-item function is called, within a time interval ?

Thank you.

Answer 1

You could put a static bool that, if true, exit from the function.

Answer 2

Probably better to make your update trigger manually.

Answer 3

If you're ok with a timer and using the Win32 API, you could use the SetTimer method to start a timer to trigger in the future each time the function is called. The behavior of SetTimer is that if you call it again with the same TimerID before the first call has gone off, then the timer gets reset. So you can call SetTimer each time the function is called and you'd be guaranteed the timer would only trigger "n" milliseconds after the last call.

  UINT_PTR timerID = SetTimer(NULL, someUniqueID, 1000, yourCallback);

Just remember to call KillTimer afterwards to cleanup.

MSDN for SetTimer

Answer 4

You need to aggregate the updates to the container over a period of time and then perform your update actions after this time period (easier said than done!). It's important that you are clear which actions are appropriate to aggregate together and which aren't.

The real point is that if you are worried about performance in an area then that is the area that you should concentrate your efforts on e.g. if you are performing UI update actions at a frequency much higher than your UI display update frequency (or higher than you practically need) then that is the code that should aggregate it's update over the time interval.

You also need to ensure that you don't leave data structures stale so that the last notification will be acted upon within a timely fashion, even if the next update doesn't happen for a long time.

Answer 5

// Not quite real code.
bool function_impl(params)
{
    // Do the work.
    return true;
}

void function(params)
{
    static bool temp(function_impl(params));
}

Answer 6

The best solution (IMHO) is the one that .NET uses for most of it's controls:

Create some sort of a "SuspendLayout" method that sets a boolean and only update the GUI if it is not set. Add a "ResumeLayout" that then updates the GUI.

This way if the user of your class only updates a single item he doesn't have to change anything and if he updates several times he can say so and your class doesn't have to worry about it.

This also allows you to optimize for batch updates if neccessary, i.e. pre-allocating more space in the list. You could also add an override to the SuspendLayout that indicates the number of items that will be added (SuspendLayout(int forNumberOfItems)) so you can initialize the list with the correct amount of space.

Answer 7

Roesone, your code is broken. It is resisting your attempts to write it because it knows it is wrong. You can probably find some grungy hack that will emit the behavior you desire -- for now. But that solution will be a hack; brittle, prone to errors and difficult to maintain. And especially vulnerable to ripple effects. As soon as you make one small change in your code somewhere in something that remotely touches this functionality, the grungy hack will break and you'll be worse off than you are now.

No, the solution here isn't to find a hack that will work. The solution is to fix your code. Fundamentally this means writing two functions. One that inserts the data in to the container, and another completely seperate function that renders that data to the screen. You can then engineer mechanisms specifically for those methods. For instance, you might update the screen ten times per second, while permitting inserts with no restrictions.

Do yourself, your coworkers and the free world a favor and fix your broken code.

Answer 8

What if you had a way to turn off the "redraw" ( GUI update ) for those situations where you want to add many items?

// add one item:
window.add_item()

// add many items:
window.set_redraw(false)
window.add_many_items()
window.set_redraw(true)

Then your add_item function simply checks the flag before updating the GUI. The simple case of adding one item remains unchanged.

Answer 9

It depends on the framework you use for GUI.

Basically, it boils down to have the following pseudo code :

bool g_isValueModified = false ;
Value g_value ;

void setValue(Value value)
{
   g_value = value ;
   g_isValueModified = true ;
}

void updateValueOnGUI()
{
   if(g_isValueModified)
   {
      g_isValueModified = false ;

      // put here the code to set the value in the GUI widget
   }
}

The method setValue should be called as much as necessary, while the method updateValueOnGUI should be callled, say, once every 10 or 100ms.

To achieve this asynchronous behaviour, either:

• if on raw Win32, use a Win32 timer to call your WinProc
• on advanced GUI framework, use a timer
• or, on advanced GUI framework, use two separate threads, one for code execution (using the set method) and one for GUI execution (executing the update), making sure g_value and g_isValueModified are written/read in multithread-safe fashion (i.e. locks, critical sections, etc.).