pasdk/common/components/clk.c

   1 /*
   2  * clk.c
   3  *
   4  *  Created on: Apr 2, 2017
   5  *      Author: a0216546
   6  */
   7
   8 #define KERNEL_BUG    0     /* Put it to 1 if you want to test for kernel bug (clock module configuration) */
   9
  10 #include <stdint.h>
  11
  12 #include <xdc/runtime/System.h>       /* for System_printf() */
  13
  14 /* BIOS Header files */
  15 #include <ti/sysbios/BIOS.h>          /* mandatory - if you call APIs like BIOS_start() */
  16 #include <ti/sysbios/knl/Semaphore.h> /* this looks obvious */
  17 #include <ti/sysbios/knl/Task.h>
  18 #include <ti/sysbios/knl/Swi.h>
  19 #include <ti/sysbios/hal/Hwi.h>
  20
  21 /* Build configurations like semaphore handles, etc. */
  22 #include <xdc/cfg/global.h>           /* header file for statically defined objects/handles */
  23
  24 /* Local Header files */
  25 #include "clk.h"
  26 #include "../pfp/pfp.h"
  27 #include "../pfp_app.h"
  28
  29 /* Macros */
  30 #define loop  while(1)
  31
  32 #include <xdc/runtime/Timestamp.h>    /* for benchmarking/profiling */
  33 #define Timestamp_get Timestamp_get32 /* use 32-bit time stamps */
  34
  35 volatile int GET_STATS_COUNT = 3000;  /* Get stats after 3000 iterations */
  36
  37 /*-----------------------------------------------------------------------------------
  38   clkWorkDelay: Waste time based on actial work
  39  *-----------------------------------------------------------------------------------*/
  40
  41 #include <math.h>
  42
  43 void clkWorkDelay(int loopcnt)
  44 {
  45   int k;
  46   volatile double x, y, z;
  47
  48   x = 3.14/6;
  49   y = 3.14/3;
  50   for (k = 0; k < loopcnt; k++) {
  51       z = sin(x)+cos(y);
  52   }
  53 } /* clkWorkDelay */
  54
  55 /*-----------------------------------------------------------------------------------
  56   clkDelay: Waste time based on time stamp
  57  *-----------------------------------------------------------------------------------*/
  58
  59 void clkDelay(uint32_t pause)
  60 {
  61   volatile uint32_t now,then;
  62
  63   now = then = Timestamp_get();
  64   while( (now-then) < pause ) {
  65     now = Timestamp_get();
  66   }
  67 } /* clkDelay */
  68
  69 #if 0
  70 /*------------------------------------------------------------
  71   clk0Fun: Wakes up task0 which runs every 100ms
  72  *------------------------------------------------------------*/
  73
  74 #if KERNEL_BUG
  75 int clk0prev = 0;
  76 #endif
  77
  78 void clk0Fun(void)
  79 {
  80   Semaphore_post(semTask0WakeUp);
  81
  82 #if KERNEL_BUG
  83   if (clk0prev == GET_STATS_COUNT) {
  84     clk0prev = -1;
  85   }
  86   else {
  87     clk0prev = GET_STATS_COUNT;
  88   }
  89 #endif
  90 } /* clk0Fun */
  91
  92 /*------------------------------------------------------------
  93   clk1Fun: Wakes up task1 which runs every 100ms
  94  *------------------------------------------------------------*/
  95
  96 #if KERNEL_BUG
  97 int clk1prev = 0;
  98 #endif
  99
 100 void clk1Fun(void)
 101 {
 102   Semaphore_post(semTask1WakeUp);
 103
 104 #if KERNEL_BUG
 105   if (clk1prev == GET_STATS_COUNT) {    /* This was used for chasing SYS/BIOS Kernel bug */
 106     clk1prev = -1;
 107   }
 108   else {
 109     clk1prev = GET_STATS_COUNT;
 110   }
 111 #endif
 112
 113 } /* clk1Fun */
 114
 115 /*-------------------------------------------------------------
 116   task0Fun: Task0 runs every 100ms and uses 30ms of time
 117  *-------------------------------------------------------------*/
 118
 119 #include <stdio.h>
 120
 121 int reset_hangover = -1;
 122
 123 //#pragma CODE_SECTION(task0Fun,".pfpsection")
 124
 125 void task0Fun(void)
 126 {
 127   int k;
 128   pfpStats_t pfp_stats;
 129   IArg swiKey, hwiKey;
 130   Task_Handle myHandle;
 131
 132   /* Task initialization */
 133   myHandle = Task_self();
 134
 135   reset_hangover = -1;          /* No need for stat reset */
 136
 137   /* Main loop */
 138   loop {
 139
 140     pfpEnd(PFP_ID_TASK0_2,0);     /* This is OK to do since the first time it would be ignored! */
 141     /* We placed the end of measurement here since we do not want to measure the printf's below
 142        which are only used at the end of the test after which we would hit a break point */
 143
 144     if (GET_STATS_COUNT > 0) {
 145       GET_STATS_COUNT--;
 146     }
 147     else {
 148       hwiKey=Hwi_disable();
 149       swiKey=Swi_disable();
 150
 151       for (k = 0; k <= PFP_ID_LAST; k++) {
 152         pfpGetStats(k, &pfp_stats);
 153         printf("ID: %02d, n=%u, C=%lld, Cmin=%u, Cmax=%u, C-avg=%g, Avg-T=%gms, Alpha=%g, C_eavg=%g, EAvg-T=%gms\n", k,
 154                pfp_stats.n_count,
 155                pfp_stats.c_total,
 156                pfp_stats.c_min,
 157                pfp_stats.c_max,
 158                (double)pfp_stats.c_total/pfp_stats.n_count,
 159                (double)pfp_stats.c_total/pfp_stats.n_count/CLK_CLOCKS_PER_MS,
 160                pfp_stats.alpha,
 161                pfp_stats.c_average,
 162                pfp_stats.c_average/CLK_CLOCKS_PER_MS);
 163       }
 164
 165       GET_STATS_COUNT = 3000;
 166       reset_hangover = 3;     /* <----------- you may put Breakpoint here! */
 167       Swi_restore(swiKey);
 168       Hwi_restore(hwiKey);
 169     }
 170
 171     /* This code "recovers" after the breakpoint in order to "ignore" pending interrupts */
 172     if (reset_hangover > 0) {
 173       reset_hangover--;
 174     }
 175     else if (reset_hangover == 0) {
 176       reset_hangover = -1;
 177
 178       hwiKey=Hwi_disable();
 179       swiKey=Swi_disable();
 180
 181       for (k = 2; k <= PFP_ID_LAST; k++) {      /* Do not reset the first two PP's */
 182         pfpResetStats(k);
 183       }
 184
 185       Swi_restore(swiKey);
 186       Hwi_restore(hwiKey);
 187     }
 188
 189     pfpBegin(PFP_ID_TASK0_2, myHandle);
 190
 191     /*-------------------------------------------------------------------------------------*/
 192     Semaphore_pend(semTask0WakeUp, BIOS_WAIT_FOREVER);  /* wait for clk0Fun to wake you up */
 193     /*-------------------------------------------------------------------------------------*/
 194
 195     /* Waste time for 20ms */
 196     pfpBegin(PFP_ID_TASK0_1, myHandle);
 197       clkWorkDelay(20*CLK_WORKCNT_PER_MS);
 198     pfpEnd(PFP_ID_TASK0_1,0);
 199
 200     /* Spend another 10ms but outside of previous profile point */
 201     clkWorkDelay(10*CLK_WORKCNT_PER_MS);
 202
 203   }
 204
 205   /* Never come here */
 206
 207 } /* task0Fun */
 208
 209 /*-------------------------------------------------------------
 210   task1Fun: Task1 runs every 100ms and uses 23ms of time
 211  *-------------------------------------------------------------*/
 212
 213 //#pragma CODE_SECTION(task1Fun,".pfpsection")
 214
 215 void task1Fun(void)
 216 {
 217   Task_Handle myHandle;
 218
 219   /* Task initialization */
 220   myHandle = Task_self();
 221
 222   /* Main loop */
 223   loop {
 224
 225     pfpEnd(PFP_ID_TASK1_3, 0);
 226     pfpBegin(PFP_ID_TASK1_3, myHandle);          /* Measure "everything else" in this task! */
 227
 228     /*-------------------------------------------------------------------------------------*/
 229     Semaphore_pend(semTask1WakeUp, BIOS_WAIT_FOREVER);  /* wait for clk1Fun to wake you up */
 230     /*-------------------------------------------------------------------------------------*/
 231
 232     /* Waste time for 13ms */
 233     pfpBegin(PFP_ID_TASK1_1, myHandle);
 234       clkWorkDelay(13*CLK_WORKCNT_PER_MS);
 235     pfpEnd(PFP_ID_TASK1_1, 0);
 236
 237     pfpBegin(PFP_ID_TASK1_2, myHandle);
 238       clkWorkDelay(8*CLK_WORKCNT_PER_MS);
 239     pfpEnd(PFP_ID_TASK1_2, 1);      /* latch this measurement */
 240
 241     pfpBegin(PFP_ID_TASK1_2, myHandle);
 242       clkWorkDelay(2*CLK_WORKCNT_PER_MS);
 243     pfpEnd(PFP_ID_TASK1_2, 0);      /* Complete this measurement */
 244
 245   }
 246
 247
 248   /* Never come here */
 249
 250 } /* task1Fun */
 251
 252 #endif
 253
 254 /* nothing past this point */
 255