home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1993 / 9 / 02 / multitasking / task.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-01  |  3.1 KB  |  116 lines
  1. /* Dieses Programm demonstriert die Task-Generation
  2.  * und eine mögliche Kommunikationsfähigekeit.
  3.  * Beim Kompilieren unbedingt die StackCheck-Option
  4.  * deaktivieren.
  5.  * Programmautor: Rainer Zeitler
  6.  */
  7. #include <exec/types.h>
  8. #include <exec/memory.h>
  9. #include <exec/tasks.h>
  10. #include <proto/dos.h>
  11. #include <proto/exec.h>
  12. #include <stdio.h>
  13.  
  14. #define TASKPRI   0L
  15. #define TASKNAME  "TochterTask"
  16. #define STACKSIZE 1000L
  17.  
  18. /* Darüber läßt sich nachvollziehen, daß der
  19.  * Tochtertask überhaupt seine Arbeit verrichtete
  20.  */
  21. ULONG TochterCounter=0;
  22.  
  23. /* Signal-Bits für die Kommunikation */
  24. ULONG TochterStartedSig=0,StopTochterTaskSig=0;
  25.  
  26. /* Der Task des Hauptprogramms */
  27. struct Task *MainTask;
  28.  
  29. void __saveds __interrupt TochterTask(void) {
  30.   /* Das Stopsignal anlegen */
  31.   StopTochterTaskSig=AllocSignal(-1L);
  32.  
  33.   /* Dem Haupttask mitteilen, daß wir soweit sind */
  34.   Signal( MainTask, 1L<<TochterStartedSig );
  35.  
  36.   /* Solange die Variable hochzählen, bis das Stop-
  37.    * Signal geschickt wird
  38.    */
  39.   while( (SetSignal(0L,0L) &
  40.                     (1L<<StopTochterTaskSig)) == 0)
  41.     TochterCounter++;
  42.  
  43.   /* Signal wieder freigeben */
  44.   FreeSignal( StopTochterTaskSig );
  45.  
  46.   /* Beenden bestätigen */
  47.   Signal( MainTask, 1L<<TochterStartedSig );
  48.  
  49.   /* Wichtig: So schläft der Task für immer und
  50.    * wir können ihn gefahrlos via RemTask()
  51.    * entfernen
  52.    */
  53.   Wait(0);
  54. }
  55.  
  56. main(long argc, char **argv) {
  57.   struct Task *Tochter=AllocMem(sizeof(struct Task),
  58.                             MEMF_CLEAR|MEMF_PUBLIC);
  59.   APTR   TaskStack=AllocMem(STACKSIZE,
  60.                             MEMF_CLEAR|MEMF_PUBLIC);
  61.  
  62.   /* Die Adresse unseres Tasks */
  63.   MainTask=FindTask(NULL);
  64.  
  65.   if( Tochter && TaskStack )
  66.   {
  67.     TochterStartedSig=AllocSignal(-1L);
  68.     if( TochterStartedSig )
  69.     {
  70.       /* Priorität des Tochter-Tasks */
  71.       Tochter->tc_Node.ln_Pri = TASKPRI;
  72.       /* Jawoll, es ist ein Task */
  73.       Tochter->tc_Node.ln_Type = NT_TASK;
  74.       /* Der Name des Tochter-Tasks */
  75.       Tochter->tc_Node.ln_Name = TASKNAME;
  76.  
  77.       /* Untere Grenze des Tochter-Task-Stacks */
  78.       Tochter->tc_SPLower = TaskStack;
  79.       /* Obere Grenze des Tochter-Task-Stacks */
  80.       Tochter->tc_SPUpper = Tochter->tc_SPReg =
  81.               (APTR)((ULONG)TaskStack+STACKSIZE);
  82.       /* Task starten */
  83.       AddTask(Tochter,(APTR)TochterTask,0L);
  84.  
  85.       /* Warten, bis der TochterTask sich meldet */
  86.       printf("Warte auf TochterTask\n");
  87.       Wait( 1L<<TochterStartedSig );
  88.       printf("TochterTask hat sich gemeldet\n"
  89.                             "5 Sekunden warten\n");
  90.       Delay( 5 * 50 );
  91.  
  92.       /* Den TochterTask beenden */
  93.       printf("Beende TochterTask und warte"
  94.                              " auf Bestätigung\n");
  95.       Signal( Tochter, 1L<<StopTochterTaskSig );
  96.  
  97.       /* Auf Bestätigung warten */
  98.       Wait( 1L<<TochterStartedSig );
  99.       printf("TochterTask beendet\n");
  100.  
  101.       printf("Zählerstand: %ld\n",TochterCounter);
  102.  
  103.       /* Task entfernen */
  104.       RemTask( Tochter );
  105.       /* Signal freigeben */
  106.       FreeSignal( TochterStartedSig );
  107.     }
  108.   }
  109.  
  110.   /* Speicher freigeben */
  111.   if( TaskStack )
  112.     FreeMem( TaskStack, STACKSIZE );
  113.   if( Tochter )
  114.     FreeMem( Tochter, sizeof(struct Task) );
  115. }
  116.