apps/top/main.c

   1 /*
   2 ** Copyright 2002, Travis Geiselbrecht. All rights reserved.
   3 ** Distributed under the terms of the NewOS License.
   4 */
   5 #include <sys/syscalls.h>
   6 #include <newos/errors.h>
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11
  12 typedef struct thread_time {
  13         struct thread_time *next;
  14
  15         struct thread_info info;
  16
  17         bigtime_t last_user_time;
  18         bigtime_t last_kernel_time;
  19
  20         bigtime_t delta_user_time;
  21         bigtime_t delta_kernel_time;
  22
  23         bool touched;
  24 } thread_time;
  25
  26 static thread_time *times = NULL;
  27
  28 static thread_time *find_in_list(thread_id id)
  29 {
  30         thread_time *tt;
  31
  32         for(tt = times; tt; tt = tt->next) {
  33                 if(id == tt->info.id)
  34                         return tt;
  35         }
  36         return NULL;
  37 }
  38
  39 static void insert_in_list(thread_time *tt)
  40 {
  41         tt->next = times;
  42         times = tt;
  43 }
  44
  45 static void prune_untouched(void)
  46 {
  47         thread_time *tt, *last;
  48
  49         last = NULL;
  50         tt = times;
  51         while(tt) {
  52                 thread_time *temp;
  53                 if(!tt->touched) {
  54                         // prune this entry
  55                         if(!last)
  56                                 times = tt->next;
  57                         else
  58                                 last->next = tt->next;
  59                         temp = tt;
  60                         tt = tt->next;
  61                         free(temp);
  62                 } else {
  63                         tt->touched = false;
  64                         last = tt;
  65                         tt = tt->next;
  66                 }
  67         }
  68 }
  69
  70 // unused
  71 #if 0
  72 static void sort_times(void)
  73 {
  74         thread_time *curr, *next, *last;
  75         bool done;
  76
  77         do {
  78                 done = true;
  79                 last = NULL;
  80                 curr = times;
  81                 while(curr) {
  82                         next = curr->next;
  83                         if(!next)
  84                                 break;
  85
  86                         if((curr->delta_user_time + curr->delta_kernel_time) > (next->delta_user_time + next->delta_kernel_time)) {
  87                                 done = false;
  88
  89                                 // swap the two
  90                                 if(last)
  91                                         times = next;
  92                                 else
  93                                         last->next = next;
  94                                 curr->next = next->next;
  95                                 next->next = curr;
  96                         }
  97                         last = curr;
  98                         curr = curr->next;
  99                 }
 100         } while(!done);
 101 }
 102 #endif
 103
 104 static int gather_info(void)
 105 {
 106         struct proc_info pi;
 107         struct thread_info ti;
 108         thread_time *tt;
 109         int err;
 110         uint32 cookie, cookie2;
 111
 112         // walk through each thread in the system
 113         cookie = 0;
 114         for(;;) {
 115                 err = _kern_proc_get_next_proc_info(&cookie, &pi);
 116                 if(err < 0)
 117                         break;
 118
 119                 cookie2 = 0;
 120                 for(;;) {
 121                         err = _kern_thread_get_next_thread_info(&cookie2, pi.pid, &ti);
 122                         if(err < 0)
 123                                 break;
 124
 125                         tt = find_in_list(ti.id);
 126                         if(!tt) {
 127                                 // create a new one
 128                                 tt = malloc(sizeof(thread_time));
 129                                 if(!tt)
 130                                         return ERR_NO_MEMORY;
 131
 132                                 memset(&tt->info, 0, sizeof(struct thread_info));
 133
 134                                 insert_in_list(tt);
 135                         }
 136
 137                         // save the last user and kernel time
 138                         tt->last_user_time = tt->info.user_time;
 139                         tt->last_kernel_time = tt->info.kernel_time;
 140
 141                         // save the new data
 142                         memcpy(&tt->info, &ti, sizeof(ti));
 143
 144                         // calculate the delta time
 145                         tt->delta_user_time = tt->info.user_time - tt->last_user_time;
 146                         tt->delta_kernel_time = tt->info.kernel_time - tt->last_kernel_time;
 147
 148                         tt->touched = true;
 149                 }
 150         }
 151
 152         // prune any untouched entries
 153         prune_untouched();
 154
 155         // sort the entries
 156 //      sort_times();
 157
 158         return 0;
 159 }
 160
 161 static int display_info(void)
 162 {
 163         thread_time *tt;
 164         bigtime_t total_user = 0;
 165         bigtime_t total_kernel = 0;
 166
 167         // clear and home the screen
 168         printf("%c[2J%c[H", 0x1b, 0x1b);
 169
 170         // print the thread dump
 171         printf("   tid   pid   pri    usertime  kerneltime                            name\n");
 172         for(tt = times; tt; tt = tt->next) {
 173                 printf("%6d%6d%6d%12Ld%12Ld%32s\n",
 174                         tt->info.id, tt->info.owner_proc_id, tt->info.priority, tt->delta_user_time, tt->delta_kernel_time, tt->info.name);
 175                 total_user += tt->delta_user_time;
 176                 total_kernel += tt->delta_kernel_time;
 177         }
 178         printf("%18s%12Ld%12Ld\n", "total:", total_user, total_kernel);
 179
 180         return 0;
 181 }
 182
 183 int main(int argc, char **argv)
 184 {
 185         int err;
 186
 187         for(;;) {
 188                 // gather data about each of the threads in the system
 189                 err = gather_info();
 190                 if(err < 0)
 191                         return err;
 192
 193                 err = display_info();
 194                 if(err < 0)
 195                         return err;
 196
 197                 usleep(1000000);
 198         }
 199 }
 200
 201