Changeset dec16a2 in mainline for uspace/app/top/screen.c


Ignore:
Timestamp:
2010-04-18T16:52:47Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5c45ca8
Parents:
e535eeb
Message:
  • sysinfo items "system.tasks" and "system.threads" now return complete statistics of all tasks and threads (statistics of individual tasks and threads can be still acquited from "system.tasks.#" and "system.threads.#")
  • update user space functions accordingly
  • cleanup top — it is fully functional again
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/top/screen.c

    re535eeb rdec16a2  
    11/*
    22 * Copyright (c) 2010 Stanislav Kozina
     3 * Copyright (c) 2010 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    3839#include <io/console.h>
    3940#include <vfs/vfs.h>
    40 #include <load.h>
    41 #include <kernel/ps/taskinfo.h>
    42 #include <ps.h>
     41#include <stdarg.h>
     42#include <stats.h>
     43#include <inttypes.h>
    4344#include "screen.h"
    4445#include "top.h"
    45 #include "func.h"
    46 
    47 int rows;
    48 int colls;
    49 int up_rows;
    50 
    51 #define WHITE 0xf0f0f0
    52 #define BLACK 0x000000
    53 
    54 static void print_float(ps_float f, int precision)
    55 {
    56         printf("%2u.", f.upper / f.lower);
    57         int i;
    58         unsigned int rest = (f.upper % f.lower) * 10;
    59         for (i = 0; i < precision; ++i) {
    60                 printf("%d", rest / f.lower);
    61                 rest = (rest % f.lower) * 10;
    62         }
    63 }
    64 
    65 static void resume_normal(void)
     46
     47#define WHITE  0xf0f0f0
     48#define BLACK  0x000000
     49
     50static int rows;
     51static int colls;
     52static int up_rows;
     53
     54static void print_float(fixed_float ffloat, unsigned int precision)
     55{
     56        printf("%2" PRIu64 ".", ffloat.upper / ffloat.lower);
     57       
     58        unsigned int i;
     59        uint64_t rest = (ffloat.upper % ffloat.lower) * 10;
     60        for (i = 0; i < precision; i++) {
     61                printf("%" PRIu64, rest / ffloat.lower);
     62                rest = (rest % ffloat.lower) * 10;
     63        }
     64}
     65
     66static void screen_resume_normal(void)
    6667{
    6768        fflush(stdout);
    … …  
    6970}
    7071
     72static void screen_moveto(int r, int c)
     73{
     74        fflush(stdout);
     75        console_goto(fphone(stdout), c, r);
     76}
     77
     78static void screen_clear(void)
     79{
     80        console_clear(fphone(stdout));
     81        screen_moveto(0, 0);
     82        up_rows = 0;
     83        fflush(stdout);
     84}
     85
    7186void screen_init(void)
    7287{
     88        console_cursor_visibility(fphone(stdout), 0);
     89        screen_resume_normal();
     90        screen_clear();
     91       
    7392        console_get_size(fphone(stdout), &colls, &rows);
    74         up_rows = 0;
    75         console_cursor_visibility(fphone(stdout), 0);
    76         resume_normal();
    77         clear_screen();
    78 }
    79 
    80 void clear_screen(void)
    81 {
    82         console_clear(fphone(stdout));
    83         moveto(0, 0);
    84         up_rows = 0;
    85         fflush(stdout);
    86 }
    87 
    88 void moveto(int r, int c)
    89 {
    90         fflush(stdout);
    91         console_goto(fphone(stdout), c, r);
     93}
     94
     95void screen_done(void)
     96{
     97        screen_resume_normal();
     98        screen_clear();
     99        console_cursor_visibility(fphone(stdout), 1);
    92100}
    93101
    94102static inline void print_time(data_t *data)
    95103{
    96         printf("%02d:%02d:%02d ", data->hours, data->minutes, data->seconds);
     104        printf("%02lu:%02lu:%02lu ", data->hours, data->minutes, data->seconds);
    97105}
    98106
    99107static inline void print_uptime(data_t *data)
    100108{
    101         printf("up %4d days, %02d:%02d:%02d, ", data->uptime_d, data->uptime_h,
    102                 data->uptime_m, data->uptime_s);
     109        printf("up %u days, %02u:%02u:%02u, ", data->udays, data->uhours,
     110            data->uminutes, data->useconds);
    103111}
    104112
    105113static inline void print_load(data_t *data)
    106114{
    107         puts("load avarage: ");
    108         print_load_fragment(data->load[0], 2);
    109         puts(" ");
    110         print_load_fragment(data->load[1], 2);
    111         puts(" ");
    112         print_load_fragment(data->load[2], 2);
    113 }
    114 
    115 static inline void print_taskstat(data_t *data)
    116 {
    117         puts("Tasks: ");
    118         printf("%4u total", data->task_count);
    119 }
    120 
    121 static inline void print_threadstat(data_t *data)
    122 {
     115        printf("load avarage: ");
     116       
     117        size_t i;
     118        for (i = 0; i < data->load_count; i++) {
     119                stats_print_load_fragment(data->load[i], 2);
     120                printf(" ");
     121        }
     122}
     123
     124static inline void print_task_summary(data_t *data)
     125{
     126        printf("tasks: %u total", data->tasks_count);
     127}
     128
     129static inline void print_thread_summary(data_t *data)
     130{
     131        size_t total = 0;
     132        size_t running = 0;
     133        size_t ready = 0;
    123134        size_t sleeping = 0;
    124         size_t running = 0;
     135        size_t lingering = 0;
     136        size_t other = 0;
    125137        size_t invalid = 0;
    126         size_t other = 0;
    127         size_t total = 0;
    128         size_t i;
    129         for (i = 0; i < data->thread_count; ++i) {
    130                 ++total;
    131                 switch (data->thread_infos[i].state) {
    132                         case Invalid:
    133                         case Lingering:
    134                                 ++invalid;
    135                                 break;
    136                         case Running:
    137                         case Ready:
    138                                 ++running;
    139                                 break;
    140                         case Sleeping:
    141                                 ++sleeping;
    142                                 break;
    143                         case Entering:
    144                         case Exiting:
    145                                 ++other;
    146                                 break;
     138       
     139       
     140        size_t i;
     141        for (i = 0; i < data->threads_count; i++) {
     142                total++;
     143               
     144                switch (data->threads[i].state) {
     145                case Running:
     146                        running++;
     147                        break;
     148                case Ready:
     149                        ready++;
     150                        break;
     151                case Sleeping:
     152                        sleeping++;
     153                        break;
     154                case Lingering:
     155                        lingering++;
     156                        break;
     157                case Entering:
     158                case Exiting:
     159                        other++;
     160                        break;
     161                default:
     162                        invalid++;
    147163                }
    148164        }
    149         printf("Threads: %5u total, %5u running, %5u sleeping, %5u invalid, %5u other",
    150                 total, running, sleeping, invalid, other);
    151 }
    152 
    153 static inline void print_cpuinfo(data_t *data)
    154 {
    155         unsigned int i;
    156         uspace_cpu_info_t *cpus = data->cpus;
    157         for (i = 0; i < data->cpu_count; ++i) {
    158                 printf("Cpu%u (%4u Mhz): Busy ticks: %6llu, Idle Ticks: %6llu",
    159                         i, (unsigned int)cpus[i].frequency_mhz, cpus[i].busy_ticks,
    160                         cpus[i].idle_ticks);
     165       
     166        printf("threads: %u total, %u running, %u ready, %u sleeping, %u lingering, "
     167            "%u other, %u invalid",
     168            total, running, ready, sleeping, lingering, other, invalid);
     169}
     170
     171static inline void print_cpu_info(data_t *data)
     172{
     173        size_t i;
     174        for (i = 0; i < data->cpus_count; i++) {
     175                printf("cpu%u (%4" PRIu16 " MHz): busy ticks: "
     176                    "%" PRIu64 ", idle ticks: %" PRIu64,
     177                    data->cpus[i].id, data->cpus[i].frequency_mhz,
     178                    data->cpus[i].busy_ticks, data->cpus[i].idle_ticks);
    161179                printf(", idle: ");
    162                 print_float(data->cpu_perc[i].idle, 2);
    163                 puts("%, busy: ");
    164                 print_float(data->cpu_perc[i].busy, 2);
    165                 puts("%\n");
    166                 ++up_rows;
    167         }
    168 }
    169 
    170 static inline void print_meminfo(data_t *data)
    171 {
    172         uint64_t newsize;
    173         char suffix;
    174         order(data->mem_info.total, &newsize, &suffix);
    175         printf("Mem: %8llu %c total", newsize, suffix);
    176         order(data->mem_info.used, &newsize, &suffix);
    177         printf(", %8llu %c used", newsize, suffix);
    178         order(data->mem_info.free, &newsize, &suffix);
    179         printf(", %8llu %c free", newsize, suffix);
     180                print_float(data->cpus_perc[i].idle, 2);
     181                printf("%%, busy: ");
     182                print_float(data->cpus_perc[i].busy, 2);
     183               
     184                printf("%%\n");
     185                up_rows++;
     186        }
     187}
     188
     189static inline void print_physmem_info(data_t *data)
     190{
     191        uint64_t total;
     192        uint64_t unavail;
     193        uint64_t used;
     194        uint64_t free;
     195        char total_suffix;
     196        char unavail_suffix;
     197        char used_suffix;
     198        char free_suffix;
     199       
     200        order_suffix(data->physmem->total, &total, &total_suffix);
     201        order_suffix(data->physmem->unavail, &unavail, &unavail_suffix);
     202        order_suffix(data->physmem->used, &used, &used_suffix);
     203        order_suffix(data->physmem->free, &free, &free_suffix);
     204       
     205        printf("memory: %" PRIu64 "%c total, %" PRIu64 "%c unavail, %"
     206            PRIu64 "%c used, %" PRIu64 "%c free", total, total_suffix,
     207            unavail, unavail_suffix, used, used_suffix, free, free_suffix);
    180208}
    181209
    182210static inline void print_tasks(data_t *data, int row)
    183211{
    184         int i;
    185         for (i = 0; i < (int)data->task_count; ++i) {
    186                 if (row + i > rows)
    187                         return;
    188                 task_info_t *taskinfo = &data->taskinfos[i];
    189                 uint64_t mem;
    190                 char suffix;
    191                 order(taskinfo->virt_mem, &mem, &suffix);
    192                 printf("%8llu %8u %8llu%c ", taskinfo->taskid,
    193                         taskinfo->thread_count, mem, suffix);
    194                 task_perc_t *taskperc = &data->task_perc[i];
    195                 puts("   ");
    196                 print_float(taskperc->mem, 2);
    197                 puts("%   ");
    198                 print_float(taskperc->ucycles, 2);
    199                 puts("%   ");
    200                 print_float(taskperc->kcycles, 2);
    201                 puts("% ");
    202                 printf("%s\n", taskinfo->name);
     212        size_t i;
     213        for (i = 0; i < data->tasks_count; i++, row++) {
     214                if (row > rows)
     215                        break;
     216               
     217                uint64_t virtmem;
     218                char virtmem_suffix;
     219                order_suffix(data->tasks[i].virtmem, &virtmem, &virtmem_suffix);
     220               
     221                printf("%8" PRIu64 " %8u %8" PRIu64 "%c ", data->tasks[i].task_id,
     222                    data->tasks[i].threads, virtmem, virtmem_suffix);
     223                printf("   ");
     224                print_float(data->tasks_perc[i].virtmem, 2);
     225                printf("%%   ");
     226                print_float(data->tasks_perc[i].ucycles, 2);
     227                printf("%%   ");
     228                print_float(data->tasks_perc[i].kcycles, 2);
     229                printf("%% %s\n", data->tasks[i].name);
    203230        }
    204231}
    … …  
    208235        fflush(stdout);
    209236        console_set_rgb_color(fphone(stdout), WHITE, BLACK);
     237       
    210238        printf("      ID  Threads      Mem      %%Mem %%uCycles %%kCycles  Name");
     239       
    211240        int i;
    212241        for (i = 61; i < colls; ++i)
    213                 puts(" ");
     242                printf(" ");
     243       
    214244        fflush(stdout);
    215245        console_set_rgb_color(fphone(stdout), BLACK, WHITE);
    … …  
    220250        fflush(stdout);
    221251        console_set_rgb_color(fphone(stdout), WHITE, BLACK);
     252       
    222253        printf("      ID Calls sent Calls recv Answs sent Answs recv  IRQn recv       Forw Name");
     254       
    223255        int i;
    224256        for (i = 80; i < colls; ++i)
    225                 puts(" ");
     257                printf(" ");
     258       
    226259        fflush(stdout);
    227260        console_set_rgb_color(fphone(stdout), BLACK, WHITE);
    … …  
    230263static inline void print_ipc(data_t *data, int row)
    231264{
    232         int i;
    233         for (i = 0; i < (int)data->task_count; ++i) {
    234                 if (row + i > rows)
    235                         return;
    236                 task_info_t *taskinfo = &data->taskinfos[i];
    237                 task_ipc_info_t *ipcinfo = &taskinfo->ipc_info;
    238                 printf("%8llu ", taskinfo->taskid);
    239                 printf("%10llu %10llu %10llu %10llu %10llu %10llu ",
    240                                 ipcinfo->call_sent, ipcinfo->call_recieved,
    241                                 ipcinfo->answer_sent, ipcinfo->answer_recieved,
    242                                 ipcinfo->irq_notif_recieved, ipcinfo->forwarded);
    243                 printf("%s\n", taskinfo->name);
     265        size_t i;
     266        for (i = 0; i < data->tasks_count; i++, row++) {
     267                if (row > rows)
     268                        break;
     269               
     270                printf("%8" PRIu64 " %10" PRIu64 " %10" PRIu64 " %10" PRIu64
     271                     " %10" PRIu64 " %10" PRIu64 " %10" PRIu64 " %s\n",
     272                     data->tasks[i].task_id, data->tasks[i].ipc_info.call_sent,
     273                     data->tasks[i].ipc_info.call_recieved,
     274                     data->tasks[i].ipc_info.answer_sent,
     275                     data->tasks[i].ipc_info.answer_recieved,
     276                     data->tasks[i].ipc_info.irq_notif_recieved,
     277                     data->tasks[i].ipc_info.forwarded, data->tasks[i].name);
    244278        }
    245279}
    … …  
    247281void print_data(data_t *data)
    248282{
    249         clear_screen();
    250         fflush(stdout);
     283        screen_clear();
     284        fflush(stdout);
     285       
    251286        printf("top - ");
    252287        print_time(data);
    253288        print_uptime(data);
    254289        print_load(data);
    255         puts("\n");
    256         ++up_rows;
    257         print_taskstat(data);
    258         puts("\n");
    259         ++up_rows;
    260         print_threadstat(data);
    261         puts("\n");
    262         ++up_rows;
    263         print_cpuinfo(data);
    264         print_meminfo(data);
    265         puts("\n");
    266         ++up_rows;
    267         puts("\n");
    268         ++up_rows;
     290       
     291        printf("\n");
     292        up_rows++;
     293       
     294        print_task_summary(data);
     295       
     296        printf("\n");
     297        up_rows++;
     298       
     299        print_thread_summary(data);
     300       
     301        printf("\n");
     302        up_rows++;
     303       
     304        print_cpu_info(data);
     305        print_physmem_info(data);
     306       
     307        printf("\n");
     308        up_rows++;
     309       
     310        /* Empty row for warnings */
     311        printf("\n");
     312       
    269313        if (operation_type == OP_IPC) {
    270314                print_ipc_head();
    271                 puts("\n");
     315                printf("\n");
    272316                print_ipc(data, up_rows);
    273317        } else {
    274318                print_task_head();
    275                 puts("\n");
     319                printf("\n");
    276320                print_tasks(data, up_rows);
    277321        }
     322       
     323        fflush(stdout);
     324}
     325
     326void print_warning(const char *fmt, ...)
     327{
     328        screen_moveto(up_rows, 0);
     329       
     330        va_list args;
     331        va_start(args, fmt);
     332        vprintf(fmt, args);
     333        va_end(args);
     334       
    278335        fflush(stdout);
    279336}
Note: See TracChangeset for help on using the changeset viewer.