By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
425,666 Members | 1,784 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 425,666 IT Pros & Developers. It's quick & easy.

Main loop helper functions

P: n/a
Hello all,

I've thought about having to implement 2 functions, say
enter_main_loop(func_name); and a function called quit_application();
which terminates the program. The enter_main_loop() can be defined as
something like:
int enter_main_loop(func_name)
{
while(1)
{
func_name();
}

return 0;
}

But then how am I going to implement the quit_application(); ? The only
way I thought it could be handled is changing enter_main_loop to
something like:
int terminate = 0;

int enter_main_loop(func_name)
{
if(!terminate)
func_name();

return 0;
}

and then quit_application(); can simply do
int quit_application()
{
return (terminate = 1);
}

What do you think about this approach? Any better ways of achieving the
same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but it
isn't now, is it)?

Thanks

Jan 28 '06 #1
Share this Question
Share on Google+
6 Replies


P: n/a
gamehack wrote:
Hello all,

I've thought about having to implement 2 functions, say
enter_main_loop(func_name); and a function called quit_application();
which terminates the program. The enter_main_loop() can be defined as
something like:
int enter_main_loop(func_name)
This might as well be void enter_main_loop(...) as it never returns.
{
while(1)
{
func_name();
}

Making this redundant as well.
return 0;
}

But then how am I going to implement the quit_application(); ? The
only way I thought it could be handled is changing enter_main_loop to
something like:
int terminate = 0;

int enter_main_loop(func_name)
{
if(!terminate)
func_name();

return 0;
}
This is not at all same as your first example, as it doesn't loop.

and then quit_application(); can simply do
int quit_application()
{
return (terminate = 1);
}
Where would you call this from (and why)?

What do you think about this approach? Any better ways of achieving
the same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but it
isn't now, is it)?


I think you're on more-or-less right track. Could this be what you want:

#include <stdlib.h>

#define QUIT_LOOPIN (1)
#define KEEP_LOOPIN !(QUIT_LOOPIN)

int func_name(/* whatever */);
int quit_application(/* whatever */);
void enter_main_loop(/* whatever */);

int main(void)
{
enter_main_loop(/* whatever */);

return quit_application(/* whatever */);
}

void enter_main_loop(/* whatever */)
{
while (1)
{
if (QUIT_LOOPIN == func_name()) return;
}
}

int func_name(/* whatever */)
{
int time_to_quit = KEEP_LOOPIN;

/* do stuff possibly changing time_to_quit value */

return time_to_quit;
}

int quit_application(/* whatever */)
{
int success = EXIT_SUCCESS;

/* do cleanup stuff possibly setting success = EXIT_FAILURE */

return success;
}

Cheers

Vladimir

--
In Seattle, Washington, it is illegal to carry a concealed weapon that
is over six feet in length.

Jan 28 '06 #2

P: n/a

Vladimir S. Oka wrote:
gamehack wrote:
Hello all,

I've thought about having to implement 2 functions, say
enter_main_loop(func_name); and a function called quit_application();
which terminates the program. The enter_main_loop() can be defined as
something like:
int enter_main_loop(func_name)


This might as well be void enter_main_loop(...) as it never returns.
{
while(1)
{
func_name();
}


Making this redundant as well.
return 0;
}

But then how am I going to implement the quit_application(); ? The
only way I thought it could be handled is changing enter_main_loop to
something like:
int terminate = 0;

int enter_main_loop(func_name)
{
if(!terminate)
func_name();

return 0;
}


This is not at all same as your first example, as it doesn't loop.

and then quit_application(); can simply do
int quit_application()
{
return (terminate = 1);
}


Where would you call this from (and why)?

What do you think about this approach? Any better ways of achieving
the same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but it
isn't now, is it)?


I think you're on more-or-less right track. Could this be what you want:

#include <stdlib.h>

#define QUIT_LOOPIN (1)
#define KEEP_LOOPIN !(QUIT_LOOPIN)

int func_name(/* whatever */);
int quit_application(/* whatever */);
void enter_main_loop(/* whatever */);

int main(void)
{
enter_main_loop(/* whatever */);

return quit_application(/* whatever */);
}

void enter_main_loop(/* whatever */)
{
while (1)
{
if (QUIT_LOOPIN == func_name()) return;
}
}

int func_name(/* whatever */)
{
int time_to_quit = KEEP_LOOPIN;

/* do stuff possibly changing time_to_quit value */

return time_to_quit;
}

int quit_application(/* whatever */)
{
int success = EXIT_SUCCESS;

/* do cleanup stuff possibly setting success = EXIT_FAILURE */

return success;
}

Cheers

Vladimir

--
In Seattle, Washington, it is illegal to carry a concealed weapon that
is over six feet in length.


This is what I meant:

int func_name();
void enter_main_loop(func_name);
void quit_main_loop(void);

int terminate = 0;

void enter_main_loop(func_name)
{
while(1)
{
if(terminate != 0)
return;
else
{
func_name();
}
}
}
void quit_main_loop(void)
{
terminate = 1;
}

and then in main.c:

int main(int argc, char* argv[])
{
enter_main_loop(func_name);

return 0;
}

The only problem I can see is that func_name() can hold the termination
if it is synchronous. The func_name() function will be responsible for
making async calls(implemented with threads) to other sync functions
which operate on a call queue so I can call quit_main_loop(); from
anywhere and it will terminate the program without waiting for some
function to finish doing its work.

Thanks

Jan 28 '06 #3

P: n/a
gamehack wrote:

Vladimir S. Oka wrote:
gamehack wrote:
> Hello all,
<snip OP's first code snippet>
>
> What do you think about this approach? Any better ways of achieving
> the same effect? I'm planning to use the quit_application() in a
> multithreaded environment so I assume it should be thread-safe (but
> it isn't now, is it)?


I think you're on more-or-less right track. Could this be what you
want:

#include <stdlib.h>

#define QUIT_LOOPIN (1)
#define KEEP_LOOPIN !(QUIT_LOOPIN)

int func_name(/* whatever */);
int quit_application(/* whatever */);
void enter_main_loop(/* whatever */);

int main(void)
{
enter_main_loop(/* whatever */);

return quit_application(/* whatever */);
}

void enter_main_loop(/* whatever */)
{
while (1)
{
if (QUIT_LOOPIN == func_name()) return;
}
}

int func_name(/* whatever */)
{
int time_to_quit = KEEP_LOOPIN;

/* do stuff possibly changing time_to_quit value */

return time_to_quit;
}

int quit_application(/* whatever */)
{
int success = EXIT_SUCCESS;

/* do cleanup stuff possibly setting success = EXIT_FAILURE */

return success;
}

Cheers

Vladimir

--
In Seattle, Washington, it is illegal to carry a concealed weapon
that is over six feet in length.


This is what I meant:

int func_name();
void enter_main_loop(func_name);
void quit_main_loop(void);

int terminate = 0;

void enter_main_loop(func_name)
{
while(1)
{
if(terminate != 0)
return;
else
{
func_name();
}
}
}
void quit_main_loop(void)
{
terminate = 1;
}

and then in main.c:

int main(int argc, char* argv[])
{
enter_main_loop(func_name);

return 0;
}

The only problem I can see is that func_name() can hold the
termination if it is synchronous. The func_name() function will be
responsible for making async calls(implemented with threads) to other
sync functions which operate on a call queue so I can call
quit_main_loop(); from anywhere and it will terminate the program
without waiting for some function to finish doing its work.


You never call quit_main_loop() so your loop never ends.

If you're thinking of multi-threaded execution that is not supported by
Standard C, and is hence off topic here.

In my code above, you could call quit_main_loop() from func_name() to
determine whether it's time to quit. I misunderstood that
quit_application() does pre-exit clean-up.

Cheers

Vladimir

Jan 28 '06 #4

P: n/a
On Sat, 28 Jan 2006 16:09:16 UTC, "gamehack" <ga******@gmail.com>
wrote:
This is what I meant:

int func_name();
void enter_main_loop(func_name);
void quit_main_loop(void);
volatile int terminate = 0; /* thread save */
void enter_main_loop(func_name)
{
while(!terminate)
{
func_name();
}
}
void quit_main_loop(void)
{
terminate = 1;
}

and then in main.c:

int main(int argc, char* argv[])
{
enter_main_loop(func_name);

return 0;
}

The only problem I can see is that func_name() can hold the termination
if it is synchronous. The func_name() function will be responsible for
making async calls(implemented with threads) to other sync functions
which operate on a call queue so I can call quit_main_loop(); from
anywhere and it will terminate the program without waiting for some
function to finish doing its work.

Thanks


For your problem the standard defines volatile - even C knows nothing
about threads.
So whenever a thread needs to quit the whole app it will change
terminate to not be 0 (it is on quit_main_loop to determine that all
threads are ready to let main (and themrself die.

--
Tschau/Bye
Herbert

Visit http://www.ecomstation.de the home of german eComStation
eComStation 1.2 Deutsch ist da!
Jan 29 '06 #5

P: n/a

"gamehack" <ga******@gmail.com> wrote
I've thought about having to implement 2 functions, say
enter_main_loop(func_name); and a function called quit_application();
which terminates the program. The enter_main_loop() can be defined as
something like:
int enter_main_loop(func_name)
{
while(1)
{
func_name();
}

return 0;
}

But then how am I going to implement the quit_application(); ? The only
way I thought it could be handled is changing enter_main_loop to
something like:
int terminate = 0;

int enter_main_loop(func_name)
{
if(!terminate)
func_name();

return 0;
}

and then quit_application(); can simply do
int quit_application()
{
return (terminate = 1);
}

What do you think about this approach? Any better ways of achieving the
same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but it
isn't now, is it)?

Use setjmp() and lngjmp().

Otherwise there is no option than to make every function in your program
return a "terminate" flag.
Jan 29 '06 #6

P: n/a
Malcolm wrote:

"gamehack" <ga******@gmail.com> wrote
What do you think about this approach? Any better ways of achieving
the same effect? I'm planning to use the quit_application() in a
multithreaded environment so I assume it should be thread-safe (but
it isn't now, is it)?

Use setjmp() and lngjmp().

Otherwise there is no option than to make every function in your
program return a "terminate" flag.


<OT>
I don't think setjmp() and lngjmp() are thread safe either. I don't
think they're very safe/good practice either, threads or no threads.
</OT>

--
A classic is something that everybody wants to have read and nobody
wants to read.
-- Mark Twain

Jan 29 '06 #7

This discussion thread is closed

Replies have been disabled for this discussion.