home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rb3730 / memlab3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-28  |  10.7 KB  |  306 lines
  1. /**********************************************************/
  2. /**********************************************************/
  3. /***                                                    ***/
  4. /***  Program name: MEMLAB3.EXE                         ***/
  5. /***                                                    ***/
  6. /***  Created     : 7 May, 1990                         ***/
  7. /***                                                    ***/
  8. /***  Revised     : February, 1992                      ***/
  9. /***                                                    ***/
  10. /***  Author      : Bo Falkenberg                       ***/
  11. /***                                                    ***/
  12. /***  Purpose     : To demonstrate multiple DOS sessions***/
  13. /***                started from a OS/2 program, and    ***/
  14. /***                to show how the size of the swap    ***/
  15. /***                file varies as the sessions are     ***/
  16. /***                started and what happens to the swap***/
  17. /***                file after the sessions are stopped.***/
  18. /***                                                    ***/
  19. /***  Compile     : icc /O+ /W2 memlab3.c               ***/
  20. /***                                                    ***/
  21. /***  Execute     : memlab3 n                           ***/
  22. /***                where n = the number of DOS sessions***/
  23. /***                to be started. If nothing is        ***/
  24. /***                enterred 4 sessions will be started.***/
  25. /***                                                    ***/
  26. /***  File input  : Reads file MEMLAB3.PRO which must be***/
  27. /***                setup using an editor such as the   ***/
  28. /***                OS/2 System Editor. The file        ***/
  29. /***                contains three lines. The first     ***/
  30. /***                line contains the name of the swap  ***/
  31. /***                file including its full path. The   ***/
  32. /***                next line contains the name of the  ***/
  33. /***                program which is to be executed in  ***/
  34. /***                the DOS sessions. The path used to  ***/
  35. /***                find the program must be included.  ***/
  36. /***                The last line  contains the         ***/
  37. /***                parameter string which is to be     ***/
  38. /***                passed to the program on startup.   ***/
  39. /***                                                    ***/
  40. /**********************************************************/
  41. /**********************************************************/
  42.  
  43. /**********************************************************/
  44. /***  DEFINES                                           ***/
  45. /**********************************************************/
  46.  #define INCL_DOS
  47.  #define LENGTH       sizeof(buffer)
  48.                            /* DosFindFirst returned buffer
  49.                               size */
  50.  #define TIMEINTERVAL 10   /* Seconds to wait when checking
  51.                               swap file size */
  52.  #define MAXLOOP      10   /* No of intervals with same
  53.                               swap file size after which
  54.                               program in terminated */
  55.  #define NOSESS       4    /* No of Sessions to start */
  56.  
  57. /**********************************************************/
  58. /***  INCLUDE                                           ***/
  59. /**********************************************************/
  60.  #include        <os2.h>
  61.  #include        <stdio.h>
  62.  #include        <string.h>
  63.  #include        <stdlib.h>
  64.  
  65. /**********************************************************/
  66. /***  GLOBAL VARIABLES                                  ***/
  67. /**********************************************************/
  68.  ULONG            SessID;      /* Session ID (returned)   */
  69.  PID              DOSpid;      /* Process ID (returned)   */
  70.  USHORT           rc = 0;      /* return code             */
  71.  USHORT           frc = 0;     /* file return code        */
  72.  struct _STARTDATA StartData;  /* start program structure */
  73.  struct _FILEFINDBUF buffer;   /* file information struct */
  74.  char szFname[64];
  75.  char szProgname[64];
  76.  char szProginp[64];
  77.  FILE *fptr;
  78.  PULONG pStartedSessID;
  79.  ULONG *p;
  80.  
  81. /**********************************************************/
  82. /***  FUNCTION PROTOTYPES                               ***/
  83. /**********************************************************/
  84.  
  85. void main(int argc, char *argv[], char *envp[]);
  86. void printtrouble(void);
  87. ULONG GetSwapperSize();
  88.  
  89. /**********************************************************/
  90. /***  MAIN PROGRAM                                      ***/
  91. /**********************************************************/
  92.  
  93. void main(int argc, char *argv[], char *envp[])
  94. {
  95.    int radix = 10;
  96.    int loop;
  97.    int no_of_DOS;
  98.    char Related;
  99.    unsigned char *Title1;
  100.    unsigned char *Title2;
  101.    char chloop1[30];
  102.    char chloop2[30];
  103.    char *dummy1;
  104.    char *dummy2;
  105.    char *pchrc;
  106.    ULONG sLen;
  107.    ULONG fsize;
  108.    ULONG ulrc;
  109.    ULONG ulTargetOption;
  110.    ULONG ulSessid;
  111.    ULONG ulTimeInterval = TIMEINTERVAL * 1000;
  112.    ULONG elapsed;
  113.    ULONG loopflag;
  114.    ULONG timecount;
  115.    ULONG samecount;
  116.    ULONG savesize;
  117.  
  118. /* Default no of sessions to start                        */
  119.    no_of_DOS = NOSESS;
  120.  
  121. /* Get arguments from the command line, if present        */
  122.    if (argc >= 2)
  123.    {
  124. /* Number of sessions to start                            */
  125.       no_of_DOS = atoi (argv[1]);
  126.    }
  127.  
  128. /* Read parameters from MEMLAB3.PRO file                  */
  129.    fptr = fopen("memlab3.pro", "r");
  130.    if (fptr == (FILE *)NULL)
  131.    {
  132.       printf("\nFile MEMLAB3.PRO cannot be found\n");
  133.       return;
  134.    }
  135. /* line 1 : swapper file path and filename                */
  136.    pchrc = fgets(szFname, sizeof(szFname)-1, fptr);
  137.    if (pchrc == (char *)NULL)
  138.    {
  139.       printtrouble();
  140.       return;
  141.    }
  142.    szFname[strlen(szFname)-1] = '\0';
  143. /* line 2 : name of program to start in the DOS sessions  */
  144.    pchrc = fgets(szProgname, sizeof(szProgname)-1, fptr);
  145.    if (pchrc == (char *)NULL)
  146.    {
  147.       printtrouble();
  148.       return;
  149.    }
  150.    szProgname[strlen(szProgname)-1] = '\0';
  151. /* line 3 : parameters to be passed to the program        */
  152.    pchrc = fgets(szProginp, sizeof(szProginp)-1, fptr);
  153.    if (pchrc == (char *)NULL)
  154.    {
  155.       printtrouble();
  156.       return;
  157.    }
  158.    sLen = strlen(szProginp);
  159.    szProginp[sLen-1] = '\0';
  160.  
  161. /* Set up parameter block for DosStartSession             */
  162.    StartData.PgmName = szProgname;
  163.    StartData.PgmInputs = szProginp;
  164.    StartData.Length = 32;
  165.    StartData.FgBg = 1;
  166.  
  167.    StartData.Related = 1; /* related to parent */
  168.  
  169.    StartData.TermQ = NULL;
  170.    StartData.InheritOpt = 0;
  171.    StartData.Environment = 0;
  172.    loop = 0;
  173.    rc = 0;
  174.  
  175. /* Allocate memory to save IDs of started sessions        */
  176.    sLen = no_of_DOS * sizeof(ULONG);
  177.    frc = DosAllocMem ((PPVOID)&pStartedSessID, sLen,
  178.                       PAG_WRITE | PAG_READ | PAG_COMMIT );
  179.    if (frc != 0)
  180.    {
  181.       printf("Memory Allocation Failure, return code %u\n",frc);
  182.       exit (1);
  183.    }
  184.    p = pStartedSessID;
  185.  
  186.    /* Keep starting DOS sessions, until an error occurs   */
  187.    /* or the requested number of DOS sessions is reached. */
  188.    /* Save the IDs of the started sessions.               */
  189.    /* Display the size of the swap file before starting   */
  190.    /* any sessions and after each session is started.     */
  191.  
  192.    printf("Program MEMLAB3 is executing\n");
  193.    printf("%u DOS sessions will be started\n", no_of_DOS);
  194.    fsize = GetSwapperSize();
  195.    printf("Size of SWAPPER.DAT is now %u Kb\n", fsize);
  196.    while (!rc && loop < no_of_DOS)
  197.    {
  198.       loop++;
  199.       StartData.SessionType = 4; /* Start a DOS session       */
  200.                                  /* make the program title    */
  201.       Title1 = ". DOS\n\0";      /* with a DOS session number */
  202.       dummy1 = _itoa(loop,  chloop1, radix);
  203.       strcat (dummy1, Title1);
  204.       StartData.PgmTitle = dummy1;
  205.  
  206.       rc = DosStartSession(&StartData, &SessID, &DOSpid);
  207.       if (rc == 0)
  208.       {
  209.          printf("DOS Session no %u is started; Session ID: %u\n",
  210.                 loop, SessID);
  211.          fsize = GetSwapperSize();
  212.          printf("Size of SWAPPER.DAT is now %u Kb\n", fsize);
  213.          *p++ = SessID;
  214.        } else
  215.        {
  216.          printf("An error occurred starting Dos Session no %u\n", loop);
  217.          printf("Return code from DosStartSession = %u\n", frc);
  218.          loop = no_of_DOS;
  219.        } /* endif */
  220.    } /* endwhile */
  221.  
  222. /* Wait for a key on the keyboard to be depressed, then   */
  223. /* terminate the DOS sessions. Display the swap file size */
  224. /* after each session is terminated.                      */
  225.    printf("Press <Enter> to terminate the DOS Sessions...");
  226.    fflush(stdout);
  227.    loop = getchar();  /*wait for input */
  228.    p = pStartedSessID;
  229.    for (loop = 1; loop <= no_of_DOS; loop++)
  230.    {
  231.       ulSessid = *p++;
  232.       ulTargetOption = 0;
  233.       ulrc = DosStopSession (ulTargetOption, ulSessid);
  234.       if (ulrc == 0)
  235.       {
  236.          printf("Session with ID %u has been stopped\n", ulSessid);
  237.  
  238.          fsize = GetSwapperSize();
  239.          printf("Size of SWAPPER.DAT is now %u Kb\n", fsize);
  240.       }
  241.    }
  242.  
  243. /* Monitor the swap file size and display it at intervals */
  244. /* of TIMEINTERVAL seconds. When the size has remained    */
  245. /* constant for TIMEINTERVAL * MAXLOOP seconds, terminate */
  246. /* the program.                                           */
  247.    loopflag = TRUE;
  248.    savesize = fsize;
  249.    timecount = 1;
  250.    while (loopflag)
  251.    {
  252.       ulrc = DosSleep(ulTimeInterval);
  253.       elapsed = timecount * TIMEINTERVAL;
  254.       printf("Elapsed time since closing DOS sessions is %u seconds\n",
  255.              elapsed);
  256.       fsize = GetSwapperSize();
  257.       printf("Size of SWAPPER.DAT is now %u Kb\n", fsize);
  258.       timecount++;
  259.       samecount++;
  260.       if ( fsize != savesize)
  261.       {
  262.          savesize = fsize;
  263.          samecount = 0;
  264.       }
  265.       if (samecount == MAXLOOP - 1)
  266.       {
  267.          elapsed = MAXLOOP * TIMEINTERVAL;
  268.          printf("No change in SWAPPER.DAT size for %u seconds\n"
  269.                 "Program in terminating\n",elapsed);
  270.          loopflag = FALSE;
  271.       }
  272.  
  273.    }
  274.    exit(0);
  275. }
  276.  
  277. /* Function to report errors with MEMLAB3.PRO             */
  278. void printtrouble(void)
  279. {
  280.    printf("\nSorry, trouble reading memlab3.pro\n");
  281.    fclose(fptr);
  282.    return;
  283. }
  284.  
  285. /* Function which returns swap file size in Kb            */
  286. ULONG GetSwapperSize ()
  287. {
  288.    HDIR fhandle;
  289.    unsigned LONG count;
  290.    int fsize;
  291.  
  292.    count = 1;
  293.    fhandle = 0xFFFF;
  294.    frc = DosFindFirst (szFname, &fhandle, 0, &buffer, LENGTH,
  295.                        &count, 1L);
  296.    if (frc != 0)
  297.    {
  298.       fflush(stdout);
  299.       printf("File error :%u\n", frc);
  300.       exit(0);
  301.    } /* endif */
  302.    fsize = buffer.cbFileAlloc / 1024;  /* in Kbytes */
  303.    DosFindClose (fhandle);
  304.    return(fsize);
  305. }
  306.