API tools faq
paste
Advertisement
kernel_memory_dump

vjezba

kernel_memory_dump
Apr 22nd, 2014
160
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.20 KB | None | 0 0
raw download clone embed print report
  1. /********************************************************
  2. *        Copyright 2013 IWEDIA TECHNOLOGIES             *
  3. *********************************************************
  4. *
  5. * MODULE NAME: DTV2-KURS VJEZBA_01
  6. *
  7. * FILE NAME: $URL$
  8. *            $Date$
  9. *            $Rev$
  10. *
  11. * DESCRIPTION
  12. *
  13. * Thread synchronization using TKEL
  14. *
  15. * minuend - subtrahend = difference
  16. *
  17. *********************************************************/
  18. /********************************************************/
  19. /*                 Includes                             */
  20. /********************************************************/
  21. #include <stdio.h>
  22. #include "tkel.h"
  23. #include "tbox.h"
  24.  
  25. /********************************************************/
  26. /*                 Defines                              */
  27. /********************************************************/                      
  28. #define MAX_THREAD_COUNT 10
  29. #define MAX_QUEUE_SIZE 21
  30. #define ARRAY_SIZE 21
  31.  
  32.  
  33. /********************************************************/
  34. /*                 Macros                               */
  35. /********************************************************/
  36. #define TKEL_ASSERT(x)  if(TKEL_NO_ERR != x) \
  37.                         { \
  38.                             mTBOX_TRACE((kTBOX_NIV_CRITICAL, "TKEL ASSERT: LINE %d ERROR %d\n", __LINE__, x)); \
  39.                             mTBOX_RETURN -1; \
  40.                         }
  41.  
  42. /********************************************************/
  43. /*                 Typedefs                             */
  44. /********************************************************/
  45. typedef enum _ElementType
  46. {
  47.     TYPE_MINUEND = 1,
  48.     TYPE_SUBTRAHEND
  49. }ElementType;
  50.  
  51. /********************************************************/
  52. /*                 Global Variables                     */
  53. /********************************************************/
  54. ////////////////////////////////////
  55. static TKEL_queue_id minuendQueId;
  56. static TKEL_queue_id subtrahendQueId;  
  57. static TKEL_queue_id resultsQueId;
  58. static TKEL_qwidth msgSize;
  59. ////////////////////////////////
  60. static TKEL_qdepth maxNumber;
  61.    
  62. static TKEL_int32 minuendIndex = 0;
  63. static TKEL_int32 subtrahendIndex = 0;
  64. static TKEL_int32 resultsIndex = 0;
  65. /////////////////////////////////
  66. // m u t e x i
  67.  
  68. static TKEL_mutex_id minuendIndexMutex;
  69. static TKEL_mutex_id subtrahendIndexMutex;
  70. static TKEL_mutex_id resultsIndexMutex;
  71. ///////////////////////////////
  72. // t a s k o v i
  73. static TKEL_prio priority = 0;
  74. static TKEL_int16 stackSize = 2048;
  75. static TKEL_task_id readTask1[MAX_THREAD_COUNT];
  76. static TKEL_task_id readTask2[MAX_THREAD_COUNT];
  77. static TKEL_task_id calcTask[MAX_THREAD_COUNT];
  78. static char* taskNameRead = "readTask";
  79. static char* taskNameCalc = "calcTask";
  80.    
  81.  
  82. /********************************************************/
  83. /*                 Local Module Variables               */
  84. /********************************************************/
  85. /********************************************************/
  86. /*                 Local File Variables (static)        */
  87. /********************************************************/
  88. static int minuendArray[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
  89. static int subtrahendArray[] = {20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
  90. static int differenceArray[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  91.  
  92. static TKEL_sema_id startSemaphore;
  93. static const int VJEZBA_01 = 0;
  94.  
  95. /********************************************************/
  96. /*                 Local Functions Declarations (static)*/
  97. /********************************************************/
  98. static void readThreadFunc(void* arg); // za prvi red ili drugi red cita, paramenata
  99. // element type prvi il drugi
  100.  
  101. static void calculateThreadFunc(void *arg);
  102.  
  103. /********************************************************/
  104. /*                 Functions Definitions                */
  105. /********************************************************/
  106. int main ( int argc, char *argv[] )
  107. {
  108.     TKEL_err tkelErr;
  109.     int readThreadNum;
  110.     int calculateThreadNum;
  111.     int i;
  112.     int k;
  113.  
  114.     /* Use TBOX to init traces */
  115.     mTBOX_SET_MODULE(VJEZBA_01);
  116.     mTBOX_INIT_MOD_TRACE((VJEZBA_01, kTBOX_TRC_ALL));
  117.  
  118.     mTBOX_TRACE_ENABLED((TRUE));
  119.     mTBOX_TRACE_SYNCHRONE((TRUE));
  120.    
  121.     mTBOX_FCT_ENTER("main");
  122.     if(3 != argc)
  123.     {
  124.         mTBOX_TRACE((kTBOX_NIV_CRITICAL, "NOT ENOUGH OR TOO MANY INPUT ARGS\n"));
  125.         mTBOX_RETURN -1;
  126.     }
  127.    
  128.     /* Init TKEL */
  129.     tkelErr = TKEL_Init();
  130.     TKEL_ASSERT(tkelErr);
  131.    
  132.     /* Get input args */
  133.     sscanf(argv[1], "%d", &readThreadNum);
  134.     sscanf(argv[2], "%d", &calculateThreadNum);
  135.    
  136.     maxNumber = readThreadNum;
  137.    
  138.  
  139.     if((readThreadNum <= 0 || readThreadNum > 10) || (calculateThreadNum <= 0 || calculateThreadNum > 10))
  140.     {
  141.         mTBOX_TRACE((kTBOX_NIV_CRITICAL, "\nBAD ARGS\n"));
  142.         mTBOX_RETURN -1;
  143.     }
  144.    
  145.     /* TO_DO */
  146.     /* Create minuend and subtrahend queues */
  147.     tkelErr = TKEL_CreateQueue(maxNumber,      
  148.  
  149.                       sizeof(int),
  150.  
  151.                          &minuendQueId);
  152.     TKEL_ASSERT(tkelErr);
  153.  
  154.     tkelErr = TKEL_CreateQueue(maxNumber,      
  155.  
  156.                       sizeof(int),
  157.  
  158.                          &subtrahendQueId);
  159.     TKEL_ASSERT(tkelErr);    
  160.  
  161. // TKEL_err TKEL_DeleteMutex(TKEL_mutex_id MutexID);
  162. // TKEL_DeleteQueue
  163. //
  164.  
  165.  
  166.     /* TO_DO */
  167.     /* Create mutexes and semaphores */
  168.     tkelErr = TKEL_CreateSemaphore(MAX_THREAD_COUNT*3, &startSemaphore);
  169.     TKEL_ASSERT(tkelErr);
  170.  
  171.  
  172.  
  173.     tkelErr = TKEL_CreateMutex(&minuendIndexMutex);
  174.     TKEL_ASSERT(tkelErr);
  175.     tkelErr = TKEL_CreateMutex(&subtrahendIndexMutex);
  176.     TKEL_ASSERT(tkelErr);
  177.     tkelErr = TKEL_CreateMutex(&resultsIndexMutex);
  178.     TKEL_ASSERT(tkelErr);
  179.    
  180.    
  181.    
  182.    
  183.     /* TO_DO */
  184.     /* Create minuend, subtrahend and calculation threads using given functions*/
  185.  
  186.  
  187.  
  188.     for (  k = 0; k<readThreadNum; k++)
  189.     {
  190.       tkelErr = TKEL_CreateTask ( priority, taskNameRead, stackSize,
  191.                 readThreadFunc, (void*)TYPE_MINUEND, &readTask1[k]);
  192.        TKEL_ASSERT(tkelErr);       
  193.     }          
  194.    for (  k = 0; k<readThreadNum; k++)
  195.     {
  196.     tkelErr = TKEL_CreateTask ( priority, taskNameRead, stackSize,
  197.                 readThreadFunc, (void*)TYPE_SUBTRAHEND, &readTask2[k]);
  198.     TKEL_ASSERT(tkelErr);
  199.     }    
  200.  
  201.    for (  k = 0; k<calculateThreadNum; k++)
  202.     {
  203.     tkelErr = TKEL_CreateTask ( priority, taskNameCalc, stackSize,
  204.                 readThreadFunc, (void*)TYPE_SUBTRAHEND, &calcTask[k]);
  205.     TKEL_ASSERT(tkelErr);
  206. }
  207.    
  208.     /* TO_DO */
  209.     /* Trigger start semaphore for all threads */
  210.     tkelErr = TKEL_SignalSemaphore(startSemaphore);
  211.     TKEL_ASSERT(tkelErr);
  212.    
  213.     /* TO_DO */
  214.     /* Wait for threads to finish */
  215.  
  216.    
  217.     /* TO_DO */
  218.     /* Deinit everything */
  219.  
  220.  
  221.  
  222.    for (  k = 0; k<readThreadNum; k++)
  223.    {
  224.     tkelErr = TKEL_DeleteTask(readTask1[k]);
  225.     TKEL_ASSERT(tkelErr);
  226.   }
  227.  
  228.    for (  k = 0; k<readThreadNum; k++)
  229.    {
  230.     tkelErr = TKEL_DeleteTask(readTask2[k]);
  231.     TKEL_ASSERT(tkelErr);
  232.   }
  233.  
  234.    for (  k = 0; k<calculateThreadNum; k++)
  235.    {
  236.     tkelErr = TKEL_DeleteTask(readTask2[k]);
  237.     TKEL_ASSERT(tkelErr);
  238.   }
  239.  
  240.     tkelErr = TKEL_DeleteSemaphore(startSemaphore);
  241.     TKEL_ASSERT(tkelErr);
  242.  
  243.     tkelErr = TKEL_DeleteMutex(minuendIndexMutex);
  244.     TKEL_ASSERT(tkelErr);
  245.     tkelErr = TKEL_DeleteMutex(subtrahendIndexMutex);
  246.     TKEL_ASSERT(tkelErr);
  247.     tkelErr = TKEL_DeleteMutex(resultsIndexMutex);
  248.     TKEL_ASSERT(tkelErr);
  249.  
  250.     tkelErr = TKEL_DeleteQueue(minuendQueId);
  251.     TKEL_ASSERT(tkelErr);
  252.     tkelErr = TKEL_DeleteQueue(subtrahendQueId);
  253.     TKEL_ASSERT(tkelErr);
  254.  
  255.    
  256.     /* Print result */
  257.     printf("\nResult: ");
  258.     for(i = 0; i < ARRAY_SIZE; i++)
  259.     {
  260.         printf("%d  ", differenceArray[i]);
  261.     }
  262.     printf("\n");
  263.     mTBOX_RETURN 0;
  264. }
  265.  
  266. void readThreadFunc(void* arg)
  267. {
  268.     ElementType threadType = (ElementType)arg;
  269.     TKEL_err tkelErr;
  270.     TKEL_WaitSemaphore(startSemaphore);
  271.     while(1)
  272.     {
  273.         switch(threadType)
  274.     {
  275.         case TYPE_MINUEND: 
  276.             TKEL_LockMutex(minuendIndexMutex);
  277.             if (minuendIndex == ARRAY_SIZE)
  278.             {
  279.                 return;
  280.             }
  281.             minuendArray[minuendIndex];
  282.             tkelErr =  TKEL_Enqueue(minuendQueId,minuendArray[minuendIndex] );
  283.             //TKEL_ASSERT(tkelErr);        
  284.             minuendIndex++;    
  285.             TKEL_UnlockMutex(minuendIndexMutex);
  286.        
  287.             break;
  288.         case TYPE_SUBTRAHEND:
  289.             TKEL_LockMutex(subtrahendIndexMutex);
  290.             if (subtrahendIndex == ARRAY_SIZE)
  291.             {
  292.                 return;
  293.             }
  294.             minuendArray[subtrahendQueId];
  295.             tkelErr =  TKEL_Enqueue(subtrahendQueId,subtrahendArray[subtrahendIndex] );
  296.             //TKEL_ASSERT(tkelErr);        
  297.             subtrahendIndex++;     
  298.             TKEL_UnlockMutex(subtrahendIndexMutex);
  299.             break;
  300.    
  301.     }
  302.    
  303.     }
  304. }
  305. void calculateThreadFunc(void *arg)
  306. {
  307.     TKEL_WaitSemaphore(startSemaphore);
  308. /*
  309. TKEL_err TKEL_Dequeue(TKEL_queue_id queueID,    
  310.  
  311.             void *message);
  312. */    
  313.  
  314.     while(1)
  315.     {
  316.         // TO_DO
  317.     TKEL_LockMutex(resultsIndexMutex);
  318.     if (subtrahendIndex == ARRAY_SIZE)
  319.     {
  320.         return;
  321.     }  
  322.     int minuend;
  323.     int subtrahend;
  324.     minuend = TKEL_Dequeue(minuendQueId, (void*) &minuend);
  325.     subtrahend =  TKEL_Dequeue(minuendQueId, (void*) &subtrahend);
  326.     differenceArray[resultsIndex]  = minuend - subtrahend;
  327.     resultsIndexMutex++;
  328.     TKEL_LockMutex(resultsIndexMutex);
  329.     }
  330. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!