Return to critsec.c CVS log

Up to [OS/2 SDKs] / os2sdk / demos / examples / critsec

Annotation of os2sdk/demos/examples/critsec/critsec.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Example of DOSENTERCRITSEC/DOSEXITCRITSEC usage.
                      3:  *
                      4:  * After a call to DOSENTERCRITSEC, a thread can be sure that it is the
                      5:  * only one in the current process running.
                      6:  * 
                      7:  * Note that critical sections, like thread suspensions, are overridden
                      8:  * by signals, so any signal handlers must be written so as not to
                      9:  * affect the resource protected by the critical section.
                     10:  * 
                     11:  * The effect of DOSENTERCRITSEC differs from the use of semaphores for
                     12:  * exclusion between threads. Semaphores allow other threads to generally
                     13:  * run, and only blocks them when they hit a locked region. This is the
                     14:  * generally preferable way to write a program. DOSENTERCRITSEC is much
                     15:  * more drastic since it freezes all other threads, regardless of whether
                     16:  * they are in a particular critical section or not. In effect this
                     17:  * function makes the entire program a critical section, and claims it for
                     18:  * one thread. This type of behaviour is rarely needed.
                     19:  *
                     20:  * In this example, one thread is using STDIO (printf()) to write to the
                     21:  * screen, and another thread is using the low level VIO function. Each
                     22:  * thread forces a critical section before writing to the screen to prevent
                     23:  * these two different routines colliding. As described above, this, and
                     24:  * most other critical section problems are better handled with a semaphore.
                     25:  *
                     26:  * compile as: cl -Ox -Zp -AL -Lp critsec.c
                     27:  *
                     28:  * Copyright (C) Microsoft Corp. 1986
                     29:  */
                     30: 
                     31: #include <doscalls.h>
                     32: #include <subcalls.h>
                     33: #include <stdio.h>
                     34: #include <malloc.h>
                     35: #include <assert.h>
                     36: 
                     37: #define STACK_SIZE     1024
                     38: 
                     39: void far f_thread(void);
                     40: int flag;
                     41: 
                     42: void main()
                     43: {
                     44:        char far *stkptr;
                     45:        unsigned thread_id, res;
                     46:        
                     47:        flag = 0;
                     48: 
                     49:        /* obtain pointer to the END of a block of memory for stack */
                     50:        stkptr = (char *)malloc(STACK_SIZE) + STACK_SIZE;
                     51:        
                     52:        /* create another thread */
                     53:        res = DOSCREATETHREAD(f_thread, &thread_id, stkptr);
                     54:        assert(res == 0);
                     55: 
                     56:        /* wait for the sub-thread to set the flag */
                     57:        while (flag == 0) {
                     58:                DOSSLEEP((long)100);
                     59:                /*
                     60:                 * Remember: testing of the flag must be atomic too.
                     61:                 * otherwize the flag will be set !0 between the test and
                     62:                 * the printf!
                     63:                 */
                     64:                DOSENTERCRITSEC();
                     65:                if (flag == 0)
                     66:                    printf("Thread 0: flag is still zero\n");
                     67:                DOSEXITCRITSEC();
                     68:        }
                     69:        
                     70:        printf("Thread 0: flag was finally set\n");
                     71:        fflush(stdout);
                     72:        DOSEXIT(1,0);
                     73: }
                     74: 
                     75: void far f_thread()
                     76: {
                     77:        /* set the flag */
                     78:        DOSSLEEP((long)1000);
                     79:        DOSENTERCRITSEC();
                     80:        flag = 1;
                     81:        VIOWRTTTY("Thread1: I am setting the flag\r\n", 33, 0);
                     82:        DOSEXITCRITSEC();
                     83:        
                     84:        /* exit this thread */
                     85:        DOSEXIT(0,0);
                     86: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.