Changeset db8a89e in rtems


Ignore:
Timestamp:
Dec 19, 2013, 8:01:23 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.11, master
Children:
fe011a5
Parents:
f466e56
Message:

cpukit/capture: Update the capture engine.

The capture did not work due to changes in the workspace allocator.
The engine now scans all existing tasks when enabled and does any
allocations then.

Fixed a bug in the ctset commandi in the CLI.

Updated the capture engine to use 64bit nanosec timestamps.

Fixed the CLI showing the stack usage.

Location:
cpukit/libmisc/capture
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libmisc/capture/capture-cli.c

    rf466e56 rdb8a89e  
    3737#include <rtems/monitor.h>
    3838
     39#define RC_UNUSED __attribute__((unused))
     40
    3941#define RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS (20)
    4042
     
    6264
    6365static void
    64 rtems_capture_cli_open (int                          argc,
    65                         char**                       argv,
    66                         const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    67                         bool                         verbose __attribute__((unused)))
     66rtems_capture_cli_open (int                                argc,
     67                        char**                             argv,
     68                        const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     69                        bool                               verbose RC_UNUSED)
    6870{
    6971  uint32_t          size = 0;
     
    133135
    134136static void
    135 rtems_capture_cli_close (int                          argc __attribute__((unused)),
    136                          char**                       argv __attribute__((unused)),
    137                          const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    138                          bool                         verbose __attribute__((unused)))
     137rtems_capture_cli_close (int                                argc RC_UNUSED,
     138                         char**                             argv RC_UNUSED,
     139                         const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     140                         bool                               verbose RC_UNUSED)
    139141{
    140142  rtems_status_code sc;
     
    161163
    162164static void
    163 rtems_capture_cli_enable (int                          argc __attribute__((unused)),
    164                           char**                       argv __attribute__((unused)),
    165                           const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    166                           bool                         verbose __attribute__((unused)))
     165rtems_capture_cli_enable (int                                argc RC_UNUSED,
     166                          char**                             argv RC_UNUSED,
     167                          const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     168                          bool                               verbose RC_UNUSED)
    167169{
    168170  rtems_status_code sc;
     
    189191
    190192static void
    191 rtems_capture_cli_disable (int                          argc __attribute__((unused)),
    192                            char**                       argv __attribute__((unused)),
    193                            const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    194                            bool                         verbose __attribute__((unused)))
     193rtems_capture_cli_disable (int                                argc RC_UNUSED,
     194                           char**                             argv RC_UNUSED,
     195                           const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     196                           bool                               verbose RC_UNUSED)
    195197{
    196198  rtems_status_code sc;
     
    217219
    218220static void
    219 rtems_capture_cli_task_list (int                          argc __attribute__((unused)),
    220                              char**                       argv __attribute__((unused)),
    221                              const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    222                              bool                         verbose __attribute__((unused)))
     221rtems_capture_cli_task_list (int                                argc RC_UNUSED,
     222                             char**                             argv RC_UNUSED,
     223                             const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     224                             bool                               verbose RC_UNUSED)
    223225{
    224226  rtems_task_priority   ceiling = rtems_capture_watch_get_ceiling ();
    225227  rtems_task_priority   floor = rtems_capture_watch_get_floor ();
    226228  rtems_capture_task_t* task = rtems_capture_get_task_list ();
    227   uint32_t              ticks;
    228   uint32_t              tick_offset;
    229   unsigned long long    total_time;
     229  rtems_capture_time_t  total_time;
    230230  int                   count = rtems_capture_task_count ();
    231231
    232   if (capture_timestamp)
    233     capture_timestamp (&ticks, &tick_offset);
    234   else
    235   {
    236     ticks = rtems_clock_get_ticks_since_boot();
    237     tick_offset = 0;
    238   }
    239 
    240   fprintf (stdout, "total %i\n", count);
     232  rtems_capture_time (&total_time);
     233
     234  fprintf (stdout, "total %i time:%Lu\n", count, (uint64_t) total_time);
    241235
    242236  while (task)
     
    245239    int32_t             stack_used;
    246240    int32_t             time_used;
     241    int                 length;
    247242
    248243    stack_used = rtems_capture_task_stack_usage (task);
    249244    if (stack_used)
    250       stack_used = (stack_used * 100) / stack_used;
     245      stack_used = (stack_used * 100) / rtems_capture_task_stack_size (task);
    251246
    252247    if (stack_used > 100)
    253248      stack_used = 100;
    254 
    255     total_time = (ticks * rtems_capture_task_time (task)) + tick_offset;
    256249
    257250    time_used = (rtems_capture_task_time (task) * 100) / total_time;
     
    265258    rtems_monitor_dump_id (rtems_capture_task_id (task));
    266259    fprintf (stdout, " ");
    267     rtems_monitor_dump_name (rtems_capture_task_name (task));
     260    rtems_monitor_dump_name (rtems_capture_task_id (task));
    268261    fprintf (stdout, " ");
    269262    rtems_monitor_dump_priority (rtems_capture_task_start_priority (task));
     
    273266    rtems_monitor_dump_priority (rtems_capture_task_curr_priority (task));
    274267    fprintf (stdout, " ");
    275     rtems_monitor_dump_state (rtems_capture_task_state (task));
     268    length = rtems_monitor_dump_state (rtems_capture_task_state (task));
     269    fprintf (stdout, "%*c", 14 - length, ' ');
    276270    fprintf (stdout, " %c%c",
    277271             rtems_capture_task_valid (task) ? 'a' : 'd',
     
    288282               rtems_capture_watch_global_on () ? 'g' : '-');
    289283    }
    290     fprintf (stdout, " %3" PRId32 "%% %3" PRId32 "%% (%" PRIu32 ")\n",
    291             stack_used, time_used, rtems_capture_task_ticks (task));
     284    fprintf (stdout, " %3" PRId32 "%% %3" PRId32 "%% (%" PRIu64 ")\n",
     285            stack_used, time_used, rtems_capture_task_time (task));
    292286
    293287    task = rtems_capture_next_task (task);
     
    305299
    306300static void
    307 rtems_capture_cli_task_load_thread (rtems_task_argument arg __attribute__((unused)))
     301rtems_capture_cli_task_load_thread (rtems_task_argument arg RC_UNUSED)
    308302{
    309303  rtems_task_priority ceiling = rtems_capture_watch_get_ceiling ();
     
    316310    unsigned long long    load[RTEMS_CAPTURE_CLI_MAX_LOAD_TASKS + 1];
    317311    rtems_capture_task_t* task;
    318     unsigned long long    total_time;
     312    rtems_capture_time_t  total_time;
    319313    int                   count = 0;
    320314    int                   i;
     
    340334      if (rtems_capture_task_valid (task))
    341335      {
    342         unsigned long long l = rtems_capture_task_delta_time (task);
     336        rtems_capture_time_t l = rtems_capture_task_delta_time (task);
    343337
    344338        count++;
     
    370364    fprintf (stdout, "\x1b[H\x1b[J Press ENTER to exit.\n\n");
    371365    fprintf (stdout,
    372              "     PID NAME RPRI CPRI STATE  %%CPU     %%STK FLGS    EXEC TIME\n");
     366             "     PID NAME RPRI CPRI STATE          %%CPU     %%STK FLGS    EXEC TIME\n");
    373367
    374368    if (count > last_count)
     
    391385      stack_used = rtems_capture_task_stack_usage (tasks[i]);
    392386      if (stack_used)
    393         stack_used = (stack_used * 100) / stack_used;
     387        stack_used = (stack_used * 100) / rtems_capture_task_stack_size (tasks[i]);
    394388
    395389      if (stack_used > 100)
     
    403397      rtems_monitor_dump_id (rtems_capture_task_id (tasks[i]));
    404398      fprintf (stdout, " ");
    405       rtems_monitor_dump_name (rtems_capture_task_name (tasks[i]));
     399      rtems_monitor_dump_name (rtems_capture_task_id (tasks[i]));
    406400      fprintf (stdout, "  ");
    407401      rtems_monitor_dump_priority (priority);
     
    410404      fprintf (stdout, " ");
    411405      k = rtems_monitor_dump_state (rtems_capture_task_state (tasks[i]));
    412       fprintf (stdout, "%*c %3i.%03i%% ", 6 - k, ' ',
     406      fprintf (stdout, "%*c %3i.%03i%% ", 14 - k, ' ',
    413407               task_load / 1000, task_load % 1000);
    414408      fprintf (stdout, "%3i%% %c%c", stack_used,
     
    425419                rtems_capture_watch_global_on () ? 'g' : '-');
    426420
    427       fprintf (stdout, "   %qi\n", rtems_capture_task_time (tasks[i]));
     421      fprintf (stdout, "   %qi\n",
     422               rtems_capture_task_time (tasks[i]));
    428423    }
    429424
     
    456451
    457452static void
    458 rtems_capture_cli_task_load (int                          argc __attribute__((unused)),
    459                              char**                       argv __attribute__((unused)),
    460                              const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    461                              bool                         verbose __attribute__((unused)))
     453rtems_capture_cli_task_load (int                                argc RC_UNUSED,
     454                             char**                             argv RC_UNUSED,
     455                             const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     456                             bool                               verbose RC_UNUSED)
    462457{
    463458  rtems_status_code   sc;
     
    529524
    530525static void
    531 rtems_capture_cli_watch_list (int                          argc __attribute__((unused)),
    532                               char**                       argv __attribute__((unused)),
    533                               const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    534                               bool                         verbose __attribute__((unused)))
     526rtems_capture_cli_watch_list (int                                argc RC_UNUSED,
     527                              char**                             argv RC_UNUSED,
     528                              const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     529                              bool                               verbose RC_UNUSED)
    535530{
    536531  rtems_capture_control_t* control = rtems_capture_get_control_list ();
     
    619614
    620615static bool
    621 rtems_capture_cli_get_name_id (char*          arg,
    622                                bool*          valid_name,
    623                                bool*          valid_id,
    624                                rtems_name*    name,
    625                                rtems_id*      id)
     616rtems_capture_cli_get_name_id (char*       arg,
     617                               bool*       valid_name,
     618                               bool*       valid_id,
     619                               rtems_name* name,
     620                               rtems_id*   id)
    626621{
    627622  size_t l;
     
    681676
    682677static void
    683 rtems_capture_cli_watch_add (int                          argc,
    684                              char**                       argv,
    685                              const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    686                              bool                         verbose __attribute__((unused)))
     678rtems_capture_cli_watch_add (int                                argc,
     679                             char**                             argv,
     680                             const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     681                             bool                               verbose RC_UNUSED)
    687682{
    688683  rtems_status_code sc;
     
    744739
    745740static void
    746 rtems_capture_cli_watch_del (int                          argc,
    747                              char**                       argv,
    748                              const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    749                              bool                         verbose __attribute__((unused)))
     741rtems_capture_cli_watch_del (int                                argc,
     742                             char**                             argv,
     743                             const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     744                             bool                               verbose RC_UNUSED)
    750745{
    751746  rtems_status_code sc;
     
    806801
    807802static void
    808 rtems_capture_cli_watch_control (int                          argc,
    809                                  char**                       argv,
    810                                  const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    811                                  bool                         verbose __attribute__((unused)))
     803rtems_capture_cli_watch_control (int                                argc,
     804                                 char**                             argv,
     805                                 const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     806                                 bool                               verbose RC_UNUSED)
    812807{
    813808  rtems_status_code sc;
     
    873868
    874869static void
    875 rtems_capture_cli_watch_global (int                          argc,
    876                                 char**                       argv,
    877                                 const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    878                                 bool                         verbose __attribute__((unused)))
     870rtems_capture_cli_watch_global (int                                argc,
     871                                char**                             argv,
     872                                const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     873                                bool                               verbose RC_UNUSED)
    879874{
    880875  rtems_status_code sc;
     
    927922
    928923static void
    929 rtems_capture_cli_watch_ceiling (int                          argc,
    930                                  char**                       argv,
    931                                  const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    932                                  bool                         verbose __attribute__((unused)))
     924rtems_capture_cli_watch_ceiling (int                                argc,
     925                                 char**                             argv,
     926                                 const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     927                                 bool                               verbose RC_UNUSED)
    933928{
    934929  rtems_status_code   sc;
     
    978973
    979974static void
    980 rtems_capture_cli_watch_floor (int                          argc,
    981                                char**                       argv,
    982                                const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    983                                bool                         verbose __attribute__((unused)))
     975rtems_capture_cli_watch_floor (int                                argc,
     976                               char**                             argv,
     977                               const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     978                               bool                               verbose RC_UNUSED)
    984979{
    985980  rtems_status_code   sc;
     
    10831078  bool                         trigger_set = false;
    10841079  bool                         is_from = false;
     1080  bool                         is_to = false;
    10851081  rtems_name                   name = 0;
    10861082  rtems_id                     id = 0;
     
    11381134      if (strcmp (arg[argv], "from") == 0)
    11391135      {
    1140         if (is_from)
     1136        if (from_valid_name || from_valid_id)
    11411137          fprintf (stdout, "warning: extra 'from' ignored\n");
    11421138
    1143         is_from = 1;
     1139        is_from = true;
     1140        continue;
     1141      }
     1142
     1143      if (strcmp (arg[argv], "to") == 0)
     1144      {
     1145        if (to_valid_name || from_valid_id)
     1146          fprintf (stdout, "warning: extra 'to' ignored\n");
     1147
     1148        is_to = true;
    11441149        continue;
    11451150      }
     
    11511156      if (valid_name)
    11521157      {
     1158        if (!is_from && !is_to)
     1159          is_to = true;
     1160
    11531161        if (is_from)
    11541162        {
     
    11591167          }
    11601168          else
    1161             fprintf (stdout, "warning: extra arguments ignored\n");
     1169            fprintf (stdout, "warning: extra name arguments ignored\n");
    11621170        }
    11631171        else if (!to_valid_name && !to_valid_id)
     
    11671175        }
    11681176        else
    1169           fprintf (stdout, "warning: extra arguments ignored\n");
     1177          fprintf (stdout, "warning: extra name arguments ignored\n");
    11701178      }
    11711179
    11721180      if (valid_id)
    11731181      {
     1182        if (!is_from && !is_to)
     1183          is_to = true;
     1184
    11741185        if (is_from)
    11751186        {
     
    11801191          }
    11811192          else
    1182             fprintf (stdout, "warning: extra arguments ignored\n");
     1193            fprintf (stdout, "warning: extra id arguments ignored\n");
    11831194        }
    11841195        else if (!to_valid_name && !to_valid_id)
     
    11881199        }
    11891200        else
    1190           fprintf (stdout, "warning: extra arguments ignored\n");
     1201          fprintf (stdout, "warning: extra id arguments ignored\n");
    11911202      }
    11921203    }
     
    12021213  if (!to_valid_name && !to_valid_id && !from_valid_name && !from_valid_id)
    12031214  {
    1204     fprintf (stdout, trigger_set_usage);
     1215    fprintf (stdout, trigger_set_usage, set ? "ctset" : "ctclear");
    12051216    return;
    12061217  }
     
    12561267
    12571268static void
    1258 rtems_capture_cli_trigger_set (int                          argc,
    1259                                char**                       argv,
    1260                                const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    1261                                bool                         verbose __attribute__((unused)))
     1269rtems_capture_cli_trigger_set (int                                argc,
     1270                               char**                             argv,
     1271                               const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     1272                               bool                               verbose RC_UNUSED)
    12621273{
    12631274  rtems_capture_cli_trigger_worker (1, argc, argv);
     
    12741285
    12751286static void
    1276 rtems_capture_cli_trigger_clear (int                          argc,
    1277                                  char**                       argv,
    1278                                  const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    1279                                  bool                         verbose __attribute__((unused)))
     1287rtems_capture_cli_trigger_clear (int                                argc,
     1288                                 char**                             argv,
     1289                                 const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     1290                                 bool                               verbose RC_UNUSED)
    12801291{
    12811292  rtems_capture_cli_trigger_worker (0, argc, argv);
     
    12921303
    12931304static void
    1294 rtems_capture_cli_trace_records (int                          argc,
    1295                                  char**                       argv,
    1296                                  const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    1297                                  bool                         verbose __attribute__((unused)))
     1305rtems_capture_cli_trace_records (int                                argc,
     1306                                 char**                             argv,
     1307                                 const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     1308                                 bool                               verbose RC_UNUSED)
    12981309{
    12991310  rtems_status_code       sc;
     
    13631374      if (csv)
    13641375        fprintf (stdout, "%08" PRIxPTR ",%03" PRIu32
    1365                    ",%03" PRIu32 ",%04" PRIx32 ",%" PRId32 ",%" PRId32 "\n",
    1366                 (uintptr_t) rec->task,
    1367                 (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
    1368                 (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) & 0xff,
    1369                 (rec->events >> RTEMS_CAPTURE_EVENT_START),
    1370                 rec->ticks, rec->tick_offset);
     1376                   ",%03" PRIu32 ",%04" PRIx32 ",%" PRId64 "\n",
     1377                 (uintptr_t) rec->task,
     1378                 (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
     1379                 (rec->events >> RTEMS_CAPTURE_CURR_PRIORITY_EVENT) & 0xff,
     1380                 (rec->events >> RTEMS_CAPTURE_EVENT_START),
     1381                 (uint64_t) rec->time);
    13711382      else
    13721383      {
    1373         unsigned long long t;
    1374         uint32_t     event;
    1375         int                e;
     1384        rtems_capture_time_t t;
     1385        uint32_t             event;
     1386        int                  e;
    13761387
    13771388        event = rec->events >> RTEMS_CAPTURE_EVENT_START;
    13781389
    1379         t  = rec->ticks;
    1380         t *= rtems_capture_tick_time ();
    1381         t += rec->tick_offset;
     1390        t = rec->time;
    13821391
    13831392        for (e = RTEMS_CAPTURE_EVENT_START; e < RTEMS_CAPTURE_EVENT_END; e++)
     
    13851394          if (event & 1)
    13861395          {
    1387             fprintf (stdout, "%9li.%06li ", (unsigned long) (t / 1000000),
    1388                     (unsigned long) (t % 1000000));
     1396            fprintf (stdout, "%9li.%06li ",
     1397                     (unsigned long) (t / 1000000000ULL),
     1398                     (unsigned long) (t % 1000000000ULL));
    13891399            rtems_monitor_dump_id (rtems_capture_task_id (rec->task));
    1390             fprintf (stdout, " ");
    1391             rtems_monitor_dump_name (rtems_capture_task_name (rec->task));
     1400            fprintf (stdout, " %c%c%c%c",
     1401                     (char) (rec->task->name >> 24) & 0xff,
     1402                     (char) (rec->task->name >> 16) & 0xff,
     1403                     (char) (rec->task->name >> 8) & 0xff,
     1404                     (char) (rec->task->name >> 0) & 0xff);
    13921405            fprintf (stdout, " %3" PRId32 " %3" PRId32 " %s\n",
    13931406                    (rec->events >> RTEMS_CAPTURE_REAL_PRIORITY_EVENT) & 0xff,
     
    14231436
    14241437static void
    1425 rtems_capture_cli_flush (int                          argc,
    1426                          char**                       argv,
    1427                          const rtems_monitor_command_arg_t* command_arg __attribute__((unused)),
    1428                          bool                         verbose __attribute__((unused)))
     1438rtems_capture_cli_flush (int                                argc,
     1439                         char**                             argv,
     1440                         const rtems_monitor_command_arg_t* command_arg RC_UNUSED,
     1441                         bool                               verbose RC_UNUSED)
    14291442{
    14301443  rtems_status_code sc;
  • cpukit/libmisc/capture/capture.c

    rf466e56 rdb8a89e  
    3030
    3131#include "capture.h"
     32
    3233#include <rtems/score/statesimpl.h>
     34#include <rtems/score/todimpl.h>
    3335
    3436/*
     
    8284static rtems_task_priority      capture_ceiling;
    8385static rtems_task_priority      capture_floor;
    84 static uint32_t                 capture_tick_period;
    8586static rtems_id                 capture_reader;
    8687
     
    113114 * by the user get the time from that.
    114115 */
    115 static inline void rtems_capture_get_time (uint32_t* ticks,
    116                                            uint32_t* tick_offset)
     116static inline void
     117rtems_capture_get_time (rtems_capture_time_t* time)
    117118{
    118119  if (capture_timestamp)
    119     capture_timestamp (ticks, tick_offset);
     120    capture_timestamp (time);
    120121  else
    121122  {
    122     *ticks       = rtems_clock_get_ticks_since_boot();
    123     *tick_offset = 0;
     123    _TOD_Get_uptime(time);
    124124  }
    125125}
     
    397397  rtems_capture_control_t* control;
    398398  rtems_name               name;
     399  rtems_capture_time_t     time;
    399400  bool                     ok;
    400401
     
    406407    return NULL;
    407408  }
     409
     410  /*
     411   * Get the current time.
     412   */
     413  rtems_capture_get_time (&time);
    408414
    409415  /*
     
    421427  task->out              = 0;
    422428  task->tcb              = new_task;
    423   task->ticks            = 0;
    424   task->tick_offset      = 0;
    425   task->ticks_in         = 0;
    426   task->tick_offset_in   = 0;
     429  task->time             = 0;
     430  task->time_in          = time;
    427431  task->control          = 0;
    428   task->last_ticks       = 0;
    429   task->last_tick_offset = 0;
     432  task->last_time        = 0;
    430433
    431434  task->tcb->extensions[capture_extension_index] = task;
     
    548551          task->flags |= RTEMS_CAPTURE_TRACED;
    549552
    550         rtems_capture_get_time (&capture_in->ticks, &capture_in->tick_offset);
     553        rtems_capture_get_time (&capture_in->time);
    551554
    552555        if (capture_in == &capture_records[capture_size - 1])
     
    894897  if (capture_flags & RTEMS_CAPTURE_ON)
    895898  {
    896     uint32_t ticks;
    897     uint32_t tick_offset;
     899    rtems_capture_time_t time;
    898900
    899901    /*
     
    930932
    931933    /*
    932      * Update the execution time. Assume the tick will not overflow
     934     * Update the execution time. Assume the time will not overflow
    933935     * for now. This may need to change.
    934936     */
    935     rtems_capture_get_time (&ticks, &tick_offset);
     937    rtems_capture_get_time (&time);
    936938
    937939    /*
     
    943945    {
    944946      ht->in++;
    945       ht->ticks_in       = ticks;
    946       ht->tick_offset_in = tick_offset;
     947      ht->time_in = time;
    947948    }
    948949
     
    950951    {
    951952      ct->out++;
    952       ct->ticks += ticks - ct->ticks_in;
    953 
    954       if (capture_timestamp)
    955       {
    956         tick_offset += capture_tick_period - ct->tick_offset_in;
    957 
    958         if (tick_offset < capture_tick_period)
    959           ct->tick_offset = tick_offset;
    960         else
    961         {
    962           ct->ticks++;
    963           ct->tick_offset = tick_offset - capture_tick_period;
    964         }
    965       }
    966       else
    967       {
    968         ct->tick_offset += 100;
    969       }
     953      ct->time += time - ct->time_in;
    970954    }
    971955
     
    10291013
    10301014  /*
    1031    * Get the tick period from the BSP Configuration Table.
    1032    */
    1033   capture_tick_period = rtems_configuration_get_microseconds_per_tick();
    1034 
    1035   /*
    10361015   * Register the user extension handlers for the CAPture Engine.
    10371016   */
     
    10711050  rtems_capture_task_t*    task;
    10721051  rtems_capture_control_t* control;
    1073   rtems_capture_record_t*  records;
    10741052  rtems_status_code        sc;
    10751053
     
    10841062  capture_flags &= ~(RTEMS_CAPTURE_ON | RTEMS_CAPTURE_ONLY_MONITOR);
    10851063
    1086   records = capture_records;
    10871064  capture_records = NULL;
    10881065
     
    11371114 * This function allows control of tracing at a global level.
    11381115 */
     1116static void
     1117rtems_capture_task_setup (Thread_Control *tcb)
     1118{
     1119  rtems_capture_create_capture_task (tcb);
     1120}
     1121
    11391122rtems_status_code
    11401123rtems_capture_control (bool enable)
     
    11541137  else
    11551138    capture_flags &= ~RTEMS_CAPTURE_ON;
     1139
     1140  rtems_iterate_over_all_threads (rtems_capture_task_setup);
    11561141
    11571142  rtems_interrupt_enable (level);
     
    18421827
    18431828/*
    1844  * rtems_capture_tick_time
    1845  *
    1846  *  DESCRIPTION:
    1847  *
    1848  * This function returns the tick period in nano-seconds.
    1849  */
    1850 uint32_t
    1851 rtems_capture_tick_time (void)
    1852 {
    1853   return capture_tick_period;
     1829 * rtems_capture_time
     1830 *
     1831 *  DESCRIPTION:
     1832 *
     1833 * This function returns the current time. If a handler is provided
     1834 * by the user get the time from that.
     1835 */
     1836void
     1837rtems_capture_time (rtems_capture_time_t* uptime)
     1838{
     1839  rtems_capture_get_time(uptime);
    18541840}
    18551841
  • cpukit/libmisc/capture/capture.h

    rf466e56 rdb8a89e  
    4444 */
    4545#define RTEMS_CAPTURE_TRIGGER_TASKS (32)
     46
     47/**
     48 * rtems_capture_time_t
     49 *
     50 * DESCRIPTION:
     51 *
     52 * A capture timestamp.
     53 */
     54typedef Timestamp_Control rtems_capture_time_t;
    4655
    4756/**
     
    157166  uint32_t                     stack_size;
    158167  uint32_t                     stack_clean;
    159   uint32_t                     ticks;
    160   uint32_t                     tick_offset;
    161   uint32_t                     ticks_in;
    162   uint32_t                     tick_offset_in;
    163   uint32_t                     last_ticks;
    164   uint32_t                     last_tick_offset;
     168  rtems_capture_time_t         time;
     169  rtems_capture_time_t         time_in;
     170  rtems_capture_time_t         last_time;
    165171  rtems_capture_control_t*     control;
    166172  struct rtems_capture_task_s* forw;
     
    186192  rtems_capture_task_t* task;
    187193  uint32_t              events;
    188   uint32_t              ticks;
    189   uint32_t              tick_offset;
     194  rtems_capture_time_t  time;
    190195} rtems_capture_record_t;
    191196
     
    255260 */
    256261
    257 typedef void (*rtems_capture_timestamp)
    258                 (uint32_t* ticks, uint32_t* micro);
     262typedef void (*rtems_capture_timestamp)(rtems_capture_time_t* time);
    259263
    260264/**
     
    510514rtems_capture_release (uint32_t count);
    511515
    512 /**
    513  * rtems_capture_tick_time
    514  *
    515  *  DESCRIPTION:
    516  *
    517  * This function returns the tick period in micro-seconds.
    518  */
    519 uint32_t
    520 rtems_capture_tick_time (void);
    521 
    522516/*
    523  * rtems_capture_tick_time
    524  *
    525  *  DESCRIPTION:
    526  *
    527  * This function returns the tick period in micro-seconds.
    528  */
    529 uint32_t
    530 rtems_capture_tick_time (void);
     517 * rtems_capture_time
     518 *
     519 *  DESCRIPTION:
     520 *
     521 * This function returns the time period in nano-seconds.
     522 */
     523void
     524rtems_capture_time (rtems_capture_time_t* uptime);
    531525
    532526/**
     
    773767
    774768/**
    775  * rtems_capture_task_ticks
    776  *
    777  *  DESCRIPTION:
    778  *
    779  * This function returns the current execution time as ticks.
    780  */
    781 static inline uint32_t
    782 rtems_capture_task_ticks (rtems_capture_task_t* task)
    783 {
    784   return task->ticks;
    785 }
    786 
    787 /**
    788  * rtems_capture_task_tick_offset
    789  *
    790  *  DESCRIPTION:
    791  *
    792  * This function returns the current execution time tick offset.
    793  */
    794 static inline uint32_t
    795 rtems_capture_task_tick_offset (rtems_capture_task_t* task)
    796 {
    797   return task->tick_offset;
    798 }
    799 
    800 /**
    801769 * rtems_capture_task_time
    802770 *
     
    805773 * This function returns the current execution time.
    806774 */
    807 static inline unsigned long long
     775static inline uint64_t
    808776rtems_capture_task_time (rtems_capture_task_t* task)
    809777{
    810   unsigned long long t = task->ticks;
    811   return (t * rtems_capture_tick_time ()) + task->tick_offset;;
     778  return task->time;
    812779}
    813780
     
    820787 * last time the detla time was and now.
    821788 */
    822 static inline unsigned long long
     789static inline uint64_t
    823790rtems_capture_task_delta_time (rtems_capture_task_t* task)
    824791{
    825   unsigned long long t = task->ticks - task->last_ticks;
    826   uint32_t     o = task->tick_offset - task->last_tick_offset;
    827 
    828   task->last_ticks       = task->ticks;
    829   task->last_tick_offset = task->tick_offset;
    830 
    831   return (t * rtems_capture_tick_time ()) + o;
     792  uint64_t t = task->time - task->last_time;
     793  task->last_time = task->time;
     794  return t;
    832795}
    833796
     
    844807{
    845808  rtems_capture_task_t* task = rtems_capture_get_task_list ();
    846   uint32_t        count = 0;
     809  uint32_t              count = 0;
    847810
    848811  while (task)
Note: See TracChangeset for help on using the changeset viewer.