Return to share.c CVS log

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

Annotation of os2sdk/demos/examples/share/share.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * This example illustrates the use of shared memory and ram semaphores
        !             3:  * between separate processes.  One process reads and stores keystrokes
        !             4:  * into a circular buffer in shared memory, and another reads the buffer
        !             5:  * and writes to standard output. The output program throttles output to
        !             6:  * one character per sec so the effect of buffering can be seen. Type
        !             7:  * CONTROL-d to terminate.
        !             8:  *
        !             9:  * Note the mutual exclusion on access to the head and tail pointers of the
        !            10:  * buffer.  For a discussion, see Peterson & Silberschatz, "Operating
        !            11:  * System Concepts", 2nd ed., chapter 9.
        !            12:  *
        !            13:  * Be aware when running this that the system does keyboard buffering
        !            14:  * underneath this program, so you can type ahead more than you might think.
        !            15:  *
        !            16:  * Needs shrchild.c as companion program.
        !            17:  *
        !            18:  * Compile as: cl -AL -G2 -Lp share.c
        !            19:  *
        !            20:  * Copyright (C) Microsoft Corp. 1986
        !            21:  */
        !            22: 
        !            23: #include <doscalls.h>
        !            24: #include <subcalls.h>
        !            25: #include "share.h"             /* common declarations between processes */
        !            26: 
        !            27: #define        CHILD1PROG      "SHRCHILD.EXE"          /* child process */
        !            28: #define        CTRLd           4                       /* termination character */
        !            29: #define FBSZ           32
        !            30: 
        !            31: struct KeyData KeyData;                /* declared in subcalls.h */
        !            32: 
        !            33: main()
        !            34: {
        !            35:        unsigned        Selector;
        !            36:        struct ResultCodes childID;     /* child process id */
        !            37:        unsigned        nBytes;
        !            38:        unsigned        rc;             /* return code */
        !            39:        char            c,
        !            40:                        fbuf[FBSZ];     /* failing object buffer */
        !            41:        struct ShareRec *SmemPtr;       /* shared memory pointer */
        !            42: 
        !            43:        /* allocate the shared memory segment */
        !            44:        if (rc = DOSALLOCSHRSEG( SHRSEGSIZE, (char *)SHRSEGNAME,
        !            45:                                (unsigned *)&Selector ))  {
        !            46:                printf("alloc of shared memory failed, error: %d\n", rc);
        !            47:                DOSEXIT(1, 0);
        !            48:        }
        !            49: 
        !            50:        /* Get a far pointer from a 16 bit selector */
        !            51:        SmemPtr = (struct ShareRec *) GETSEGPTR(Selector, 0);
        !            52: 
        !            53:        /* Initialize circular buffer flags */
        !            54:        DOSSEMCLEAR((long)&(SmemPtr->fullsem));
        !            55:        DOSSEMSET((long)&(SmemPtr->emptysem));
        !            56:        DOSSEMCLEAR((long)&(SmemPtr->mutexsem));
        !            57:        SmemPtr->head = 0;
        !            58:        SmemPtr->tail = 0;
        !            59: 
        !            60:        /* exec asynchronously the consumer process */
        !            61:        if (rc = DOSEXECPGM(
        !            62:                (char *) fbuf,                  /* ObjNameBuf           */
        !            63:                (unsigned) FBSZ,                /* ObjNameLen           */
        !            64:                (unsigned) 1,                   /* AsyncTraceFlags      */
        !            65:                (char *) 0L,                    /* Argument Strings     */
        !            66:                (char *) 0L,                    /* Environment Strings  */
        !            67:                (struct ResultCodes *) &childID,
        !            68:                                                /* ID & Termination Codes */
        !            69:                (char *) CHILD1PROG )) {        /* Program Filename     */
        !            70:            
        !            71:                printf("exec of child process failed, error: %d\n", rc);
        !            72:                DOSEXIT(1, 0);
        !            73:        }
        !            74: 
        !            75:        /* Here, we read chars from the keyboard, and put them in a */
        !            76:        /* circular buffer in shared memory */
        !            77: 
        !            78:        KBDCHARIN(&KeyData, 0, 0);      /* read character from keyboard */
        !            79: 
        !            80:        while((c = KeyData.char_code) != CTRLd) {
        !            81: 
        !            82:            /* block if buffer full */
        !            83:            DOSSEMWAIT((long)&(SmemPtr->fullsem), WAITFOREVER);
        !            84: 
        !            85:            /* mutual exclusion on buffer pointers */
        !            86:            DOSSEMREQUEST((long)&(SmemPtr->mutexsem), WAITFOREVER);
        !            87:            SmemPtr->CircBuffer[SmemPtr->head] = c;
        !            88:            SmemPtr->head++;                /* step pointer */
        !            89:            SmemPtr->head %= CIRCBUFSIZE;   /* wrap at end  */
        !            90:            if(BUFFUL(SmemPtr))             /* set semaphore if buffer full */
        !            91:                DOSSEMSET((long)&(SmemPtr->fullsem));
        !            92:            DOSSEMCLEAR((long)&(SmemPtr->mutexsem));
        !            93: 
        !            94:            DOSSEMCLEAR((long)&(SmemPtr->emptysem));  /* indicate buf !emtpy */
        !            95: 
        !            96:            KBDCHARIN(&KeyData, 0, 0);  /* read character from keyboard */
        !            97:        }
        !            98:        DOSKILLPROCESS( 1, childID.TermCode_PID );      /* kill consumer */
        !            99:        DOSEXIT( 1, 0 );                /* exit, terminating all threads */
        !           100: }

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