Changes in / [f76696f:1db6dfd] in mainline
- Location:
- uspace
- Files:
-
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/app/tester/print/print1.c
rf76696f r1db6dfd 42 42 43 43 TPRINTF("Testing printf(\"%%8.10s\", \"text\"):\n"); 44 TPRINTF("Expected output: \" 44 TPRINTF("Expected output: \"text\"\n"); 45 45 TPRINTF("Real output: \"%8.10s\"\n\n", "text"); 46 46 … … 49 49 TPRINTF("Real output: \"%8.10s\"\n\n", "very long text"); 50 50 51 TPRINTF("Testing printf(\"%%-*.*s\", 7, 7, \"text\"):\n");52 TPRINTF("Expected output: \"text \"\n");53 TPRINTF("Real output: \"%-*.*s\"\n\n", 7, 7, "text");54 55 51 return NULL; 56 52 } -
uspace/app/top/screen.c
rf76696f r1db6dfd 37 37 38 38 #include <stdio.h> 39 #include <stdlib.h>40 39 #include <io/console.h> 41 40 #include <io/style.h> … … 44 43 #include <stats.h> 45 44 #include <inttypes.h> 46 #include <macros.h>47 45 #include "screen.h" 48 46 #include "top.h" … … 50 48 #define USEC_COUNT 1000000 51 49 50 static sysarg_t warn_col = 0; 51 static sysarg_t warn_row = 0; 52 52 static suseconds_t timeleft = 0; 53 53 54 54 console_ctrl_t *console; 55 55 56 static sysarg_t warning_col = 0;57 static sysarg_t warning_row = 0;58 static suseconds_t warning_timeleft = 0;59 static char *warning_text = NULL;60 61 56 static void screen_style_normal(void) 62 57 { … … 69 64 console_flush(console); 70 65 console_set_style(console, STYLE_INVERTED); 71 }72 73 static void screen_style_emphasis(void)74 {75 console_flush(console);76 console_set_style(console, STYLE_EMPHASIS);77 66 } 78 67 … … 137 126 void screen_done(void) 138 127 { 139 free(warning_text);140 warning_text = NULL;141 142 128 screen_restart(true); 143 129 … … 291 277 } 292 278 293 static inline void print_ help_head(void)279 static inline void print_tasks_head(void) 294 280 { 295 281 screen_style_inverted(); 296 printf("Help"); 282 printf("[taskid] [thrds] [resident] [%%resi] [virtual] [%%virt]" 283 " [%%user] [%%kern] [name"); 297 284 screen_newline(); 298 285 screen_style_normal(); 299 286 } 300 287 301 static inline void print_ help(void)288 static inline void print_tasks(data_t *data) 302 289 { 303 290 sysarg_t cols; … … 305 292 screen_get_size(&cols, &rows); 306 293 307 screen_newline();308 309 printf("Operation modes:");310 screen_newline();311 312 printf(" t .. tasks statistics");313 screen_newline();314 315 printf(" i .. IPC statistics");316 screen_newline();317 318 printf(" e .. exceptions statistics");319 screen_newline();320 321 printf(" a .. toggle display of all/hot exceptions");322 screen_newline();323 324 printf(" h .. toggle this help screen");325 screen_newline();326 327 screen_newline();328 329 printf("Other keys:");330 screen_newline();331 332 printf(" s .. choose column to sort by");333 screen_newline();334 335 printf(" r .. toggle reversed sorting");336 screen_newline();337 338 printf(" q .. quit");339 screen_newline();340 341 294 sysarg_t col; 342 295 sysarg_t row; 343 296 screen_get_pos(&col, &row); 344 297 298 size_t i; 299 for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) { 300 stats_task_t *task = data->tasks + data->tasks_map[i]; 301 perc_task_t *perc = data->tasks_perc + data->tasks_map[i]; 302 303 uint64_t resmem; 304 const char *resmem_suffix; 305 bin_order_suffix(task->resmem, &resmem, &resmem_suffix, true); 306 307 uint64_t virtmem; 308 const char *virtmem_suffix; 309 bin_order_suffix(task->virtmem, &virtmem, &virtmem_suffix, true); 310 311 printf("%-8" PRIu64 " %7zu %7" PRIu64 "%s ", 312 task->task_id, task->threads, resmem, resmem_suffix); 313 print_percent(perc->resmem, 2); 314 printf(" %6" PRIu64 "%s ", virtmem, virtmem_suffix); 315 print_percent(perc->virtmem, 2); 316 puts(" "); 317 print_percent(perc->ucycles, 2); 318 puts(" "); 319 print_percent(perc->kcycles, 2); 320 puts(" "); 321 print_string(task->name); 322 323 screen_newline(); 324 } 325 345 326 while (row < rows) { 346 327 screen_newline(); … … 349 330 } 350 331 351 static inline void print_table_head(const table_t *table) 332 static inline void print_ipc_head(void) 333 { 334 screen_style_inverted(); 335 printf("[taskid] [cls snt] [cls rcv] [ans snt]" 336 " [ans rcv] [irq rcv] [forward] [name"); 337 screen_newline(); 338 screen_style_normal(); 339 } 340 341 static inline void print_ipc(data_t *data) 352 342 { 353 343 sysarg_t cols; 354 344 sysarg_t rows; 355 345 screen_get_size(&cols, &rows); 356 346 347 sysarg_t col; 348 sysarg_t row; 349 screen_get_pos(&col, &row); 350 351 size_t i; 352 for (i = 0; (i < data->tasks_count) && (row < rows); i++, row++) { 353 uint64_t call_sent; 354 uint64_t call_received; 355 uint64_t answer_sent; 356 uint64_t answer_received; 357 uint64_t irq_notif_received; 358 uint64_t forwarded; 359 360 char call_sent_suffix; 361 char call_received_suffix; 362 char answer_sent_suffix; 363 char answer_received_suffix; 364 char irq_notif_received_suffix; 365 char forwarded_suffix; 366 367 order_suffix(data->tasks[i].ipc_info.call_sent, &call_sent, 368 &call_sent_suffix); 369 order_suffix(data->tasks[i].ipc_info.call_received, 370 &call_received, &call_received_suffix); 371 order_suffix(data->tasks[i].ipc_info.answer_sent, 372 &answer_sent, &answer_sent_suffix); 373 order_suffix(data->tasks[i].ipc_info.answer_received, 374 &answer_received, &answer_received_suffix); 375 order_suffix(data->tasks[i].ipc_info.irq_notif_received, 376 &irq_notif_received, &irq_notif_received_suffix); 377 order_suffix(data->tasks[i].ipc_info.forwarded, &forwarded, 378 &forwarded_suffix); 379 380 printf("%-8" PRIu64 " %8" PRIu64 "%c %8" PRIu64 "%c" 381 " %8" PRIu64 "%c %8" PRIu64 "%c %8" PRIu64 "%c" 382 " %8" PRIu64 "%c ", data->tasks[i].task_id, 383 call_sent, call_sent_suffix, 384 call_received, call_received_suffix, 385 answer_sent, answer_sent_suffix, 386 answer_received, answer_received_suffix, 387 irq_notif_received, irq_notif_received_suffix, 388 forwarded, forwarded_suffix); 389 print_string(data->tasks[i].name); 390 391 screen_newline(); 392 } 393 394 while (row < rows) { 395 screen_newline(); 396 row++; 397 } 398 } 399 400 static inline void print_excs_head(void) 401 { 357 402 screen_style_inverted(); 358 for (size_t i = 0; i < table->num_columns; i++) { 359 const char *name = table->columns[i].name; 360 int width = table->columns[i].width; 361 if (i != 0) { 362 puts(" "); 363 } 364 if (width == 0) { 365 sysarg_t col; 366 sysarg_t row; 367 screen_get_pos(&col, &row); 368 width = cols - col - 1; 369 } 370 printf("[%-*.*s]", width - 2, width - 2, name); 371 } 403 printf("[exc ] [count ] [%%count] [cycles ] [%%cycles] [description"); 372 404 screen_newline(); 373 405 screen_style_normal(); 374 406 } 375 407 376 static inline void print_ table(const table_t *table)408 static inline void print_excs(data_t *data) 377 409 { 378 410 sysarg_t cols; … … 385 417 386 418 size_t i; 387 for (i = 0; (i < table->num_fields) && (row < rows); i++) { 388 size_t column_index = i % table->num_columns; 389 int width = table->columns[column_index].width; 390 field_t *field = &table->fields[i]; 391 392 if (column_index != 0) { 393 puts(" "); 394 } 395 396 if (width == 0) { 397 screen_get_pos(&col, &row); 398 width = cols - col - 1; 399 } 400 401 switch (field->type) { 402 case FIELD_EMPTY: 403 printf("%*s", width, ""); 404 break; 405 case FIELD_UINT: 406 printf("%*" PRIu64, width, field->uint); 407 break; 408 case FIELD_UINT_SUFFIX_BIN: { 409 uint64_t val = field->uint; 410 const char *suffix; 411 width -= 3; 412 bin_order_suffix(val, &val, &suffix, true); 413 printf("%*" PRIu64 "%s", width, val, suffix); 414 break; 415 } 416 case FIELD_UINT_SUFFIX_DEC: { 417 uint64_t val = field->uint; 418 char suffix; 419 width -= 1; 420 order_suffix(val, &val, &suffix); 421 printf("%*" PRIu64 "%c", width, val, suffix); 422 break; 423 } 424 case FIELD_PERCENT: 425 width -= 5; /* nnn.% */ 426 if (width > 2) { 427 printf("%*s", width - 2, ""); 428 width = 2; 429 } 430 print_percent(field->fixed, width); 431 break; 432 case FIELD_STRING: 433 printf("%-*.*s", width, width, field->string); 434 break; 435 } 436 437 if (column_index == table->num_columns - 1) { 438 screen_newline(); 439 row++; 440 } 419 for (i = 0; (i < data->exceptions_count) && (row < rows); i++) { 420 /* Filter-out cold exceptions if not instructed otherwise */ 421 if ((!excs_all) && (!data->exceptions[i].hot)) 422 continue; 423 424 uint64_t count; 425 uint64_t cycles; 426 427 char count_suffix; 428 char cycles_suffix; 429 430 order_suffix(data->exceptions[i].count, &count, &count_suffix); 431 order_suffix(data->exceptions[i].cycles, &cycles, &cycles_suffix); 432 433 printf("%-8u %9" PRIu64 "%c ", 434 data->exceptions[i].id, count, count_suffix); 435 print_percent(data->exceptions_perc[i].count, 2); 436 printf(" %9" PRIu64 "%c ", cycles, cycles_suffix); 437 print_percent(data->exceptions_perc[i].cycles, 2); 438 puts(" "); 439 print_string(data->exceptions[i].desc); 440 441 screen_newline(); 442 row++; 441 443 } 442 444 … … 447 449 } 448 450 449 static inline void print_sort(table_t *table)451 static void print_help(void) 450 452 { 451 453 sysarg_t cols; … … 456 458 sysarg_t row; 457 459 screen_get_pos(&col, &row); 458 459 size_t num = min(table->num_columns, rows - row); 460 for (size_t i = 0; i < num; i++) { 461 printf("%c - %s", table->columns[i].key, table->columns[i].name); 460 461 screen_newline(); 462 463 printf("Operation modes:"); 464 screen_newline(); 465 466 printf(" t .. tasks statistics"); 467 screen_newline(); 468 469 printf(" i .. IPC statistics"); 470 screen_newline(); 471 472 printf(" e .. exceptions statistics"); 473 screen_newline(); 474 475 printf(" a .. toggle display of all/hot exceptions"); 476 screen_newline(); 477 478 row += 6; 479 480 while (row < rows) { 462 481 screen_newline(); 463 482 row++; 464 483 } 465 466 while (row < rows) {467 screen_newline();468 row++;469 }470 }471 472 static inline void print_warning(void)473 {474 screen_get_pos(&warning_col, &warning_row);475 if (warning_timeleft > 0) {476 screen_style_emphasis();477 print_string(warning_text);478 screen_style_normal();479 } else {480 free(warning_text);481 warning_text = NULL;482 }483 screen_newline();484 484 } 485 485 … … 492 492 print_cpu_info(data); 493 493 print_physmem_info(data); 494 print_warning(); 495 496 switch (screen_mode) { 497 case SCREEN_TABLE: 498 print_table_head(&data->table); 499 print_table(&data->table); 494 495 /* Empty row for warnings */ 496 screen_get_pos(&warn_col, &warn_row); 497 screen_newline(); 498 499 switch (op_mode) { 500 case OP_TASKS: 501 print_tasks_head(); 502 print_tasks(data); 500 503 break; 501 case SCREEN_SORT: 502 print_sort(&data->table); 504 case OP_IPC: 505 print_ipc_head(); 506 print_ipc(data); 503 507 break; 504 case SCREEN_HELP: 505 print_help_head(); 508 case OP_EXCS: 509 print_excs_head(); 510 print_excs(data); 511 break; 512 case OP_HELP: 513 print_tasks_head(); 506 514 print_help(); 507 515 } … … 510 518 } 511 519 512 void show_warning(const char *fmt, ...) 513 { 514 sysarg_t cols; 515 sysarg_t rows; 516 screen_get_size(&cols, &rows); 517 518 size_t warning_text_size = 1 + cols * sizeof(*warning_text); 519 free(warning_text); 520 warning_text = malloc(warning_text_size); 521 if (!warning_text) 522 return; 523 520 void print_warning(const char *fmt, ...) 521 { 522 screen_moveto(warn_col, warn_row); 523 524 524 va_list args; 525 525 va_start(args, fmt); 526 v snprintf(warning_text, warning_text_size,fmt, args);526 vprintf(fmt, args); 527 527 va_end(args); 528 528 529 warning_timeleft = 2 * USEC_COUNT; 530 531 screen_moveto(warning_col, warning_row); 532 print_warning(); 529 screen_newline(); 533 530 console_flush(console); 534 531 } … … 558 555 kbd_event_t event; 559 556 560 warning_timeleft -= timeleft;561 557 if (!console_get_kbd_event_timeout(console, &event, &timeleft)) { 562 558 timeleft = 0; 563 559 return -1; 564 560 } 565 warning_timeleft += timeleft;566 561 567 562 if (event.type == KEY_PRESS) -
uspace/app/top/screen.h
rf76696f r1db6dfd 43 43 extern void screen_done(void); 44 44 extern void print_data(data_t *); 45 extern void show_warning(const char *, ...);45 extern void print_warning(const char *, ...); 46 46 47 47 extern int tgetchar(unsigned int); -
uspace/app/top/top.c
rf76696f r1db6dfd 55 55 #define MINUTE 60 56 56 57 typedef enum { 58 OP_TASKS, 59 OP_IPC, 60 OP_EXCS, 61 } op_mode_t; 62 63 static const column_t task_columns[] = { 64 {"taskid", 't', 8}, 65 {"thrds", 'h', 7}, 66 {"resident", 'r', 10}, 67 {"%resi", 'R', 7}, 68 {"virtual", 'v', 9}, 69 {"%virt", 'V', 7}, 70 {"%user", 'U', 7}, 71 {"%kern", 'K', 7}, 72 {"name", 'd', 0}, 73 }; 74 75 enum { 76 TASK_COL_ID = 0, 77 TASK_COL_NUM_THREADS, 78 TASK_COL_RESIDENT, 79 TASK_COL_PERCENT_RESIDENT, 80 TASK_COL_VIRTUAL, 81 TASK_COL_PERCENT_VIRTUAL, 82 TASK_COL_PERCENT_USER, 83 TASK_COL_PERCENT_KERNEL, 84 TASK_COL_NAME, 85 TASK_NUM_COLUMNS, 86 }; 87 88 static const column_t ipc_columns[] = { 89 {"taskid", 't', 8}, 90 {"cls snt", 'c', 9}, 91 {"cls rcv", 'C', 9}, 92 {"ans snt", 'a', 9}, 93 {"ans rcv", 'A', 9}, 94 {"forward", 'f', 9}, 95 {"name", 'd', 0}, 96 }; 97 98 enum { 99 IPC_COL_TASKID = 0, 100 IPC_COL_CLS_SNT, 101 IPC_COL_CLS_RCV, 102 IPC_COL_ANS_SNT, 103 IPC_COL_ANS_RCV, 104 IPC_COL_FORWARD, 105 IPC_COL_NAME, 106 IPC_NUM_COLUMNS, 107 }; 108 109 static const column_t exception_columns[] = { 110 {"exc", 'e', 8}, 111 {"count", 'n', 10}, 112 {"%count", 'N', 8}, 113 {"cycles", 'c', 10}, 114 {"%cycles", 'C', 9}, 115 {"description", 'd', 0}, 116 }; 117 118 enum { 119 EXCEPTION_COL_ID = 0, 120 EXCEPTION_COL_COUNT, 121 EXCEPTION_COL_PERCENT_COUNT, 122 EXCEPTION_COL_CYCLES, 123 EXCEPTION_COL_PERCENT_CYCLES, 124 EXCEPTION_COL_DESCRIPTION, 125 EXCEPTION_NUM_COLUMNS, 126 }; 127 128 screen_mode_t screen_mode = SCREEN_TABLE; 129 static op_mode_t op_mode = OP_TASKS; 130 static size_t sort_column = TASK_COL_PERCENT_USER; 131 static int sort_reverse = -1; 132 static bool excs_all = false; 57 op_mode_t op_mode = OP_TASKS; 58 sort_mode_t sort_mode = SORT_TASK_CYCLES; 59 bool excs_all = false; 133 60 134 61 static const char *read_data(data_t *target) … … 140 67 target->tasks = NULL; 141 68 target->tasks_perc = NULL; 69 target->tasks_map = NULL; 142 70 target->threads = NULL; 143 71 target->exceptions = NULL; … … 148 76 target->ecycles_diff = NULL; 149 77 target->ecount_diff = NULL; 150 target->table.name = NULL;151 target->table.num_columns = 0;152 target->table.columns = NULL;153 target->table.num_fields = 0;154 target->table.fields = NULL;155 78 156 79 /* Get current time */ … … 194 117 if (target->tasks_perc == NULL) 195 118 return "Not enough memory for task utilization"; 119 120 target->tasks_map = 121 (size_t *) calloc(target->tasks_count, sizeof(size_t)); 122 if (target->tasks_map == NULL) 123 return "Not enough memory for task map"; 196 124 197 125 /* Get threads */ … … 361 289 static int cmp_data(void *a, void *b, void *arg) 362 290 { 363 field_t *fa = (field_t *)a + sort_column; 364 field_t *fb = (field_t *)b + sort_column; 365 366 if (fa->type > fb->type) 367 return 1 * sort_reverse; 368 369 if (fa->type < fb->type) 370 return -1 * sort_reverse; 371 372 switch (fa->type) { 373 case FIELD_EMPTY: 374 return 0; 375 case FIELD_UINT_SUFFIX_BIN: /* fallthrough */ 376 case FIELD_UINT_SUFFIX_DEC: /* fallthrough */ 377 case FIELD_UINT: 378 if (fa->uint > fb->uint) 379 return 1 * sort_reverse; 380 if (fa->uint < fb->uint) 381 return -1 * sort_reverse; 382 return 0; 383 case FIELD_PERCENT: 384 if (fa->fixed.upper * fb->fixed.lower 385 > fb->fixed.upper * fa->fixed.lower) 386 return 1 * sort_reverse; 387 if (fa->fixed.upper * fb->fixed.lower 388 < fb->fixed.upper * fa->fixed.lower) 389 return -1 * sort_reverse; 390 return 0; 391 case FIELD_STRING: 392 return str_cmp(fa->string, fb->string) * sort_reverse; 393 } 394 291 size_t ia = *((size_t *) a); 292 size_t ib = *((size_t *) b); 293 data_t *data = (data_t *) arg; 294 295 uint64_t acycles = data->ucycles_diff[ia] + data->kcycles_diff[ia]; 296 uint64_t bcycles = data->ucycles_diff[ib] + data->kcycles_diff[ib]; 297 298 if (acycles > bcycles) 299 return -1; 300 301 if (acycles < bcycles) 302 return 1; 303 395 304 return 0; 396 305 } 397 306 398 static void sort_table(table_t *table) 399 { 400 if (sort_column >= table->num_columns) 401 sort_column = 0; 402 /* stable sort is probably best, so we use gsort */ 403 gsort((void *) table->fields, table->num_fields / table->num_columns, 404 sizeof(field_t) * table->num_columns, cmp_data, NULL); 405 } 406 407 static const char *fill_task_table(data_t *data) 408 { 409 data->table.name = "Tasks"; 410 data->table.num_columns = TASK_NUM_COLUMNS; 411 data->table.columns = task_columns; 412 data->table.num_fields = data->tasks_count * TASK_NUM_COLUMNS; 413 data->table.fields = calloc(data->table.num_fields, 414 sizeof(field_t)); 415 if (data->table.fields == NULL) 416 return "Not enough memory for table fields"; 417 418 field_t *field = data->table.fields; 419 for (size_t i = 0; i < data->tasks_count; i++) { 420 stats_task_t *task = &data->tasks[i]; 421 perc_task_t *perc = &data->tasks_perc[i]; 422 field[TASK_COL_ID].type = FIELD_UINT; 423 field[TASK_COL_ID].uint = task->task_id; 424 field[TASK_COL_NUM_THREADS].type = FIELD_UINT; 425 field[TASK_COL_NUM_THREADS].uint = task->threads; 426 field[TASK_COL_RESIDENT].type = FIELD_UINT_SUFFIX_BIN; 427 field[TASK_COL_RESIDENT].uint = task->resmem; 428 field[TASK_COL_PERCENT_RESIDENT].type = FIELD_PERCENT; 429 field[TASK_COL_PERCENT_RESIDENT].fixed = perc->resmem; 430 field[TASK_COL_VIRTUAL].type = FIELD_UINT_SUFFIX_BIN; 431 field[TASK_COL_VIRTUAL].uint = task->virtmem; 432 field[TASK_COL_PERCENT_VIRTUAL].type = FIELD_PERCENT; 433 field[TASK_COL_PERCENT_VIRTUAL].fixed = perc->virtmem; 434 field[TASK_COL_PERCENT_USER].type = FIELD_PERCENT; 435 field[TASK_COL_PERCENT_USER].fixed = perc->ucycles; 436 field[TASK_COL_PERCENT_KERNEL].type = FIELD_PERCENT; 437 field[TASK_COL_PERCENT_KERNEL].fixed = perc->kcycles; 438 field[TASK_COL_NAME].type = FIELD_STRING; 439 field[TASK_COL_NAME].string = task->name; 440 field += TASK_NUM_COLUMNS; 441 } 442 443 return NULL; 444 } 445 446 static const char *fill_ipc_table(data_t *data) 447 { 448 data->table.name = "IPC"; 449 data->table.num_columns = IPC_NUM_COLUMNS; 450 data->table.columns = ipc_columns; 451 data->table.num_fields = data->tasks_count * IPC_NUM_COLUMNS; 452 data->table.fields = calloc(data->table.num_fields, 453 sizeof(field_t)); 454 if (data->table.fields == NULL) 455 return "Not enough memory for table fields"; 456 457 field_t *field = data->table.fields; 458 for (size_t i = 0; i < data->tasks_count; i++) { 459 field[IPC_COL_TASKID].type = FIELD_UINT; 460 field[IPC_COL_TASKID].uint = data->tasks[i].task_id; 461 field[IPC_COL_CLS_SNT].type = FIELD_UINT_SUFFIX_DEC; 462 field[IPC_COL_CLS_SNT].uint = data->tasks[i].ipc_info.call_sent; 463 field[IPC_COL_CLS_RCV].type = FIELD_UINT_SUFFIX_DEC; 464 field[IPC_COL_CLS_RCV].uint = data->tasks[i].ipc_info.call_received; 465 field[IPC_COL_ANS_SNT].type = FIELD_UINT_SUFFIX_DEC; 466 field[IPC_COL_ANS_SNT].uint = data->tasks[i].ipc_info.answer_sent; 467 field[IPC_COL_ANS_RCV].type = FIELD_UINT_SUFFIX_DEC; 468 field[IPC_COL_ANS_RCV].uint = data->tasks[i].ipc_info.answer_received; 469 field[IPC_COL_FORWARD].type = FIELD_UINT_SUFFIX_DEC; 470 field[IPC_COL_FORWARD].uint = data->tasks[i].ipc_info.forwarded; 471 field[IPC_COL_NAME].type = FIELD_STRING; 472 field[IPC_COL_NAME].string = data->tasks[i].name; 473 field += IPC_NUM_COLUMNS; 474 } 475 476 return NULL; 477 } 478 479 static const char *fill_exception_table(data_t *data) 480 { 481 data->table.name = "Exceptions"; 482 data->table.num_columns = EXCEPTION_NUM_COLUMNS; 483 data->table.columns = exception_columns; 484 data->table.num_fields = data->exceptions_count * 485 EXCEPTION_NUM_COLUMNS; 486 data->table.fields = calloc(data->table.num_fields, sizeof(field_t)); 487 if (data->table.fields == NULL) 488 return "Not enough memory for table fields"; 489 490 field_t *field = data->table.fields; 491 for (size_t i = 0; i < data->exceptions_count; i++) { 492 if (!excs_all && !data->exceptions[i].hot) 493 continue; 494 field[EXCEPTION_COL_ID].type = FIELD_UINT; 495 field[EXCEPTION_COL_ID].uint = data->exceptions[i].id; 496 field[EXCEPTION_COL_COUNT].type = FIELD_UINT_SUFFIX_DEC; 497 field[EXCEPTION_COL_COUNT].uint = data->exceptions[i].count; 498 field[EXCEPTION_COL_PERCENT_COUNT].type = FIELD_PERCENT; 499 field[EXCEPTION_COL_PERCENT_COUNT].fixed = data->exceptions_perc[i].count; 500 field[EXCEPTION_COL_CYCLES].type = FIELD_UINT_SUFFIX_DEC; 501 field[EXCEPTION_COL_CYCLES].uint = data->exceptions[i].cycles; 502 field[EXCEPTION_COL_PERCENT_CYCLES].type = FIELD_PERCENT; 503 field[EXCEPTION_COL_PERCENT_CYCLES].fixed = data->exceptions_perc[i].cycles; 504 field[EXCEPTION_COL_DESCRIPTION].type = FIELD_STRING; 505 field[EXCEPTION_COL_DESCRIPTION].string = data->exceptions[i].desc; 506 field += EXCEPTION_NUM_COLUMNS; 507 } 508 509 /* in case any cold exceptions were ignored */ 510 data->table.num_fields = field - data->table.fields; 511 512 return NULL; 513 } 514 515 static const char *fill_table(data_t *data) 516 { 517 if (data->table.fields != NULL) { 518 free(data->table.fields); 519 data->table.fields = NULL; 520 } 521 522 switch (op_mode) { 523 case OP_TASKS: 524 return fill_task_table(data); 525 case OP_IPC: 526 return fill_ipc_table(data); 527 case OP_EXCS: 528 return fill_exception_table(data); 529 } 530 return NULL; 307 static void sort_data(data_t *data) 308 { 309 size_t i; 310 311 for (i = 0; i < data->tasks_count; i++) 312 data->tasks_map[i] = i; 313 314 qsort((void *) data->tasks_map, data->tasks_count, 315 sizeof(size_t), cmp_data, (void *) data); 531 316 } 532 317 … … 571 356 if (target->ecount_diff != NULL) 572 357 free(target->ecount_diff); 573 574 if (target->table.fields != NULL)575 free(target->table.fields);576 358 } 577 359 … … 585 367 printf("Reading initial data...\n"); 586 368 587 if ((ret = read_data(&data )) != NULL)369 if ((ret = read_data(&data_prev)) != NULL) 588 370 goto out; 589 371 590 372 /* Compute some rubbish to have initialised values */ 591 compute_percentages(&data , &data);373 compute_percentages(&data_prev, &data_prev); 592 374 593 375 /* And paint screen until death */ 594 376 while (true) { 595 377 int c = tgetchar(UPDATE_INTERVAL); 596 597 if (c < 0) { /* timeout */ 598 data_prev = data; 378 if (c < 0) { 599 379 if ((ret = read_data(&data)) != NULL) { 600 free_data(&data _prev);380 free_data(&data); 601 381 goto out; 602 382 } 603 383 604 384 compute_percentages(&data_prev, &data); 385 sort_data(&data); 386 print_data(&data); 605 387 free_data(&data_prev); 606 607 c = -1; 608 } 609 610 if (screen_mode == SCREEN_HELP && c >= 0) { 611 if (c == 'h' || c == '?') 612 c = -1; 613 /* go back to table and handle the key */ 614 screen_mode = SCREEN_TABLE; 615 } 616 617 if (screen_mode == SCREEN_SORT && c >= 0) { 618 for (size_t i = 0; i < data.table.num_columns; i++) { 619 if (data.table.columns[i].key == c) { 620 sort_column = i; 621 screen_mode = SCREEN_TABLE; 622 } 623 } 624 625 c = -1; 626 } 627 388 data_prev = data; 389 390 continue; 391 } 392 628 393 switch (c) { 629 case -1: /* do nothing */630 break;631 394 case 't': 395 print_warning("Showing task statistics"); 632 396 op_mode = OP_TASKS; 633 397 break; 634 398 case 'i': 399 print_warning("Showing IPC statistics"); 635 400 op_mode = OP_IPC; 636 401 break; 637 402 case 'e': 403 print_warning("Showing exception statistics"); 638 404 op_mode = OP_EXCS; 639 405 break; 640 case 's':641 screen_mode = SCREEN_SORT;642 break;643 case 'r':644 sort_reverse = -sort_reverse;645 break;646 406 case 'h': 647 case '?':648 screen_mode = SCREEN_HELP;407 print_warning("Showing help"); 408 op_mode = OP_HELP; 649 409 break; 650 410 case 'q': … … 654 414 excs_all = !excs_all; 655 415 if (excs_all) 656 show_warning("Showing all exceptions");416 print_warning("Showing all exceptions"); 657 417 else 658 show_warning("Showing only hot exceptions");418 print_warning("Showing only hot exceptions"); 659 419 break; 660 420 } 661 /* fallthrough */662 421 default: 663 show_warning("Unknown command \"%c\", use \"h\" for help", c); 664 continue; /* don't redraw */ 665 } 666 667 if ((ret = fill_table(&data)) != NULL) { 668 goto out; 669 } 670 sort_table(&data.table); 671 print_data(&data); 422 print_warning("Unknown command \"%c\", use \"h\" for help", c); 423 break; 424 } 672 425 } 673 426 674 427 out: 675 428 screen_done(); 676 free_data(&data );429 free_data(&data_prev); 677 430 678 431 if (ret != NULL) { -
uspace/app/top/top.h
rf76696f r1db6dfd 51 51 52 52 typedef enum { 53 SCREEN_TABLE, 54 SCREEN_SORT, 55 SCREEN_HELP, 56 } screen_mode_t; 53 OP_TASKS, 54 OP_IPC, 55 OP_EXCS, 56 OP_HELP 57 } op_mode_t; 57 58 58 extern screen_mode_t screen_mode; 59 typedef enum { 60 SORT_TASK_CYCLES 61 } sort_mode_t; 62 63 extern op_mode_t op_mode; 64 extern sort_mode_t sort_mode; 65 extern bool excs_all; 59 66 60 67 typedef struct { … … 80 87 } perc_exc_t; 81 88 82 typedef enum {83 FIELD_EMPTY, FIELD_UINT, FIELD_UINT_SUFFIX_BIN, FIELD_UINT_SUFFIX_DEC,84 FIELD_PERCENT, FIELD_STRING85 } field_type_t;86 87 typedef struct {88 field_type_t type;89 union {90 fixed_float fixed;91 uint64_t uint;92 const char *string;93 };94 } field_t;95 96 typedef struct {97 const char *name;98 char key;99 int width;100 } column_t;101 102 typedef struct {103 const char *name;104 size_t num_columns;105 const column_t *columns;106 size_t num_fields;107 field_t *fields;108 } table_t;109 110 89 typedef struct { 111 90 time_t hours; … … 128 107 stats_task_t *tasks; 129 108 perc_task_t *tasks_perc; 109 size_t *tasks_map; 130 110 131 111 size_t threads_count; … … 142 122 uint64_t *ecycles_diff; 143 123 uint64_t *ecount_diff; 144 145 table_t table;146 124 } data_t; 147 125 -
uspace/lib/c/generic/io/printf_core.c
rf76696f r1db6dfd 283 283 /* Print leading spaces. */ 284 284 size_t strw = str_length(str); 285 if (precision == 0 || precision > strw)285 if (precision == 0) 286 286 precision = strw; 287 287 … … 331 331 /* Print leading spaces. */ 332 332 size_t strw = wstr_length(str); 333 if (precision == 0 || precision > strw)333 if (precision == 0) 334 334 precision = strw; 335 335
Note:
See TracChangeset
for help on using the changeset viewer.