Function Pointers and Cooperative Multitasking

2/19/13

Functi on Poi nter s and Cooper ative Multi tasking

Beej's Bit Bucket Like

0

Tweet

0

Tech and Programming Fun Tech and Programming Fun 0

2010-01-29

1

Function Pointers and Cooperative Multitasking In the Good Old Days of Days of Mac OS 9 and 9 and Windows 3.1, 3.1, there existed a notion of multitaski multitasking ng known as cooperative multitasking.. This is when the OS multitasking OS schedules schedules tasks to run, and gives the tasks complete control of the CPU for as long as they want it. Tasks would voluntarily relinquish control after not too long, so that other tasks could run. Of course, a greedy task could just take over the system and not let anything else run, but such a task would lead to an unpleasant user experience, and so such software was unpopular. In other In other words, it was iin n the the software's best bes t interest to be cooperative.

A manatee manatee very very quickly performs his "float" task before voluntarily returning control to the cooperative multitasking multitasking s ystem.

Not could greedy tasks take over o ver the the system, system, but but buggy ones could, as well! This This would would lead to system hangs, hangs, and user unhappiness. Real computer operating systems systems,, like like Un Unix ix,, BSD SD,, and Linux Linux,, shunned cooperative multitaski multitasking ng and instead used used the superior superior idea of preemptive multitasking, multitasking, in which the OS forcibly takes control c ontrol away away from a process when when that that process's proces s's time is up... no more hangs! hangs! All modern desktop OSes, including those those from Microsoft Microsoft and and Apple Apple,, have left cooperative multitasking behind. So why even even talk about it at all? Well, it's a good way to to bring bri ng up up another idea inC in C: function pointers. pointers. In an earlier article, I talked talked about a bout pointers in C, C, which are variables that hold the memory address of other o ther variab variables. les. Here's Here's the fun bit: they can hold the memory address address of functio functions, ns, too! And And then you you can call functions indirectly via the pointer to the function! What's we're we're going goi ng is use this to set up a little cooperative coope rative multitasking multitasking system. But first let's get through some of the funky C syntax. We'll need to declare a variable that's that's of type "pointer "p ointer to a function". function". We'll even be specific spec ific,, and declare declare it to be a pointer poi nter to a function function with a certain return type type and a certain parameter list. li st. E.g. "Declare "D eclare a variable named 'functionpointer' that is a pointer to a function that returns an int and takes a const char* as a parameter: int (*functionpointer (*functionpointer )(const char char *s);

// this is a function pointer

At this point poi nt,, we've we've declared a variable named "functionpointer", but it doesn't actually point at anything. Now for for comparison, compari son, here here is a function prototype for prototype for a function that returns an int*: int *functionprototype *functionprototype (const char *s); beej.us/bl og /data/functi on- pointer s- cooper ati ve- mul ti taski ng /

// function function prototype!! 1/5

2/19/13

Function Pointers and Cooperative Multitasking

int (*functionpointer )(const char *s);

// function pointer

Note the subtle difference: the parentheses. This lets the compiler know that the * is associated with the functionpointer, and not the int before it.

So let's blow out this example into something big, and actually have the functionpointer point to a function, and then let's call it. The reason I made it return int and take the const char* parameter was so that it would match another standard function in stdio.h, namely puts()—this function prints a string on the console. We'll get the address of puts(), store it in functionpointer, and then call it. To get the address of a function, you refer to it by name without parentheses. That is, puts("Hello!") calls the function normally, but puts is a pointer to the function. (You can preface it with ampersand i f you want ("&puts"), but that's not idiomatic.) So we can store a pointer to puts() in functionpointer just with the simple assignment: functionpointer = puts;

// functionpointer now points to puts

Now how do we call the function pointed to by the pointer? That is, how do we call puts() via functionpointer? Easy! We just add parenthesis and arguments and call it like a normal function: functionpointer("Hello, world!"); // just like puts("Hello, world!")

And here's a full-blown example of the above stuff: C

#include int main(void) { // declare a variable named "functionpointer" that is a pointer to a // function that returns and int and takes one parameter: a const // char *: int (*functionpointer )(const char *s); // initialize functionpointer to point to the built-in puts() // function: functionpointer = puts; // now call the function via the pointer: functionpointer ("This is just like calling puts()!"); return 0; }

Of course, all this so far have been for illustrative purposes and is marginally useful at best. Something in C that's actually common is to use function pointers in the library functions qsort() and bsearch(). These functions accept as a parameter a pointer to a comparison function, which compares two values and returns the result. The qsort() function uses the results of the comparison function to help sort an array. The advantage of this approach is that qsort()'s behavior can beej.us/blog/data/function-pointers-cooperative-multitasking/

2/5

2/19/13


be modified by passing it pointers to different comparison functions, and a generalized qsort() routine that can sort arbitrary types of data can be shipped for everyone to use. For instance, here is a program that sorts arrays. One array is sorted forward, and one is sorted backward. The only difference in the qsort() call is the comparison function used: C

#include #include int sort_ascending (const void *a, const void *b) { return *(int*)a > *(int*)b; } int sort_descending (const void *a, const void *b) { return *(int*)a < *(int*)b; } int main(void) { int array1[5] = { 9, 2, 6, 1, 7 }; int array2[5] = { 9, 2, 6, 1, 7 }; // give qsort() a pointer to the "sort_ascending" // comparison function: qsort(array1, 5, sizeof(int), sort_ascending ); // give qsort() a pointer to the "sort_descending" // comparison function: qsort(array2, 5, sizeof(int), sort_descending ); return 0; }

Anyway, where were we? Oh yeah—let's see if we can use this to set up a simple cooperative multitasking system. The basic idea here is that we're going to have a bunch of "tasks", and each task will have an associated function that does all the work of that task. Each function will be called in turn, and each function is expected to return before too much time has elapsed (so it doesn't hog the system). We'll have a structure called tasklist that knows how many active tasks there are, and knows which functions are associated with those tasks. How many tasks is easy: it's an int. But we have to have a list of functions for each task... a list of pointers to functions... an array of pointers functions... an array of pointers to functions that return void and have no parameters. Man, how do you declare that? Again the syntax is funky, but it is what it is. Here's an example declaration of an array of poi nters to functions, with 10 elements: void (*task_function[10])(void);

There we've declared an array of pointers to functions, and that array is named "task_function". Here's an assignment to the third array element (index 2) and a beej.us/blog/data/function-pointers-cooperative-multitasking/

3/5

2/19/13


subsequent call to it: task_function[2] = foo; task_function[2]();

// assign to point to function foo // call it (call foo(), that is)

For this final example, we'll make up three tasks: one for Manatees, one for Goats, and one for Bats. Each task's function does a short thing and then returns control so it can go on to the next function. In main() the task list is initialized with three tasks, and the task function pointers are stored in the task function pointer array. The main loop then runs through the task list and dispatches each one in order, and then starts over again, round-robin style. In this example, it does it forever, but that's just my arbitrary decision. C

#include #define MAX_TASKS 10 struct tasklist { int task_count; void (*task_function[MAX_TASKS])(void); }; void manatee_float_and_graze (void) { printf(" The manatee is floating and grazing.\n"); } void goat_stand_on_item (void) { printf(" The goat is standing on an item.\n"); } void bat_eat_insects (void) { printf(" The bat is eating insects.\n"); } int main(void) { int i; struct tasklist tl; tl.task_count = 3; tl.task_function[0] = manatee_float_and_graze ; tl.task_function[1] = goat_stand_on_item ; tl.task_function[2] = bat_eat_insects ; while (1) { printf ("Dispatching:\n"); for (i = 0; i < tl.task_count; i++) { tl.task_function[i](); // execute the task's function } } return 0; }

And this gives the following output: Dispatching: The manatee is floating and grazing. The goat is standing on an item. beej.us/blog/data/function-pointers-cooperative-multitasking/

4/5

2/19/13


The bat is eating insects. Dispatching: The manatee is floating and grazing. The goat is standing on an item. The bat is eating insects. Dispatching: The manatee is floating and grazing. . . . [forever]

Ways to improve this might be to pass a pointer to a data chunk to each task so it could maintain some state between calls. Or you could choose a different scheduling algorithm that would call tasks in an order other than round-robin. Or you could allow the system to dynamically create and destroy tasks as needed. For fun sometime in the future I might write a piece on scheduling and priorities and so on.

Share me! Like

0

Tweet

0

0

1

Historic Comments Show

Comments 0 comments

1

Leave a message...

Discussion

Community

Blog

beej.us/blog/data/function-pointers-cooperative-multitasking/

Share

Email [email protected]

Home page

5/5

Function Pointers and Cooperative Multitasking

Recommend Documents