Changeset a35b458 in mainline for uspace/dist
- Timestamp:
- 2018-03-02T20:10:49Z (8 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- f1380b7
- Parents:
- 3061bc1
- git-author:
- Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
- git-committer:
- Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
- Location:
- uspace/dist/src/c/demos
- Files:
-
- 10 edited
-
edit/edit.c (modified) (20 diffs)
-
edit/search.c (modified) (8 diffs)
-
edit/sheet.c (modified) (1 diff)
-
tetris/scores.c (modified) (7 diffs)
-
tetris/screen.c (modified) (21 diffs)
-
tetris/shapes.c (modified) (2 diffs)
-
tetris/tetris.c (modified) (23 diffs)
-
top/screen.c (modified) (26 diffs)
-
top/top.c (modified) (16 diffs)
-
top/top.h (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
uspace/dist/src/c/demos/edit/edit.c
r3061bc1 ra35b458 88 88 */ 89 89 int ideal_column; 90 90 91 91 char *previous_search; 92 92 bool previous_search_reverse; … … 532 532 pane.rflags |= REDRAW_TEXT; 533 533 } 534 534 535 535 if (update_ideal_column) 536 536 pane.ideal_column = c_new.column; 537 537 538 538 caret_update(); 539 539 } … … 608 608 const char *old_fname = (doc.file_name != NULL) ? doc.file_name : ""; 609 609 char *fname; 610 610 611 611 fname = prompt("Save As", old_fname); 612 612 if (fname == NULL) { … … 815 815 816 816 /* Clear the remaining rows if file is short. */ 817 817 818 818 int i; 819 819 sysarg_t j; … … 905 905 console_flush(con); 906 906 } 907 907 908 908 if ((csel_end.row == rbc.row) && (csel_end.column == s_column)) { 909 909 console_flush(con); … … 911 911 console_flush(con); 912 912 } 913 913 914 914 c = str_decode(row_buf, &pos, size); 915 915 if (c != '\t') { … … 966 966 int n = printf(" %d, %d (%d): File '%s'. Ctrl-Q Quit Ctrl-S Save " 967 967 "Ctrl-E Save As", coord.row, coord.column, last_row, fname); 968 968 969 969 int pos = scr_columns - 1 - n; 970 970 printf("%*s", pos, ""); … … 1151 1151 coord.row = row; 1152 1152 coord.column = column; 1153 1153 1154 1154 spt_t pt; 1155 1155 sheet_get_cell_pt(doc.sh, &coord, align_dir, &pt); 1156 1156 1157 1157 caret_move(pt, select, true); 1158 1158 } … … 1196 1196 { 1197 1197 char *sline; 1198 1198 1199 1199 sline = prompt("Go to line", ""); 1200 1200 if (sline == NULL) { … … 1202 1202 return; 1203 1203 } 1204 1204 1205 1205 char *endptr; 1206 1206 int line = strtol(sline, &endptr, 10); … … 1211 1211 } 1212 1212 free(sline); 1213 1213 1214 1214 caret_move_absolute(line, pane.ideal_column, dir_before, false); 1215 1215 } … … 1270 1270 { 1271 1271 char *pattern; 1272 1272 1273 1273 const char *prompt_text = "Find next"; 1274 1274 if (reverse) 1275 1275 prompt_text = "Find previous"; 1276 1276 1277 1277 const char *default_value = ""; 1278 1278 if (pane.previous_search) 1279 1279 default_value = pane.previous_search; 1280 1280 1281 1281 pattern = prompt(prompt_text, default_value); 1282 1282 if (pattern == NULL) { … … 1284 1284 return; 1285 1285 } 1286 1286 1287 1287 if (pane.previous_search) 1288 1288 free(pane.previous_search); 1289 1289 pane.previous_search = pattern; 1290 1290 pane.previous_search_reverse = reverse; 1291 1291 1292 1292 search(pattern, reverse); 1293 1293 } … … 1299 1299 return; 1300 1300 } 1301 1301 1302 1302 search(pane.previous_search, pane.previous_search_reverse); 1303 1303 } … … 1306 1306 { 1307 1307 status_display("Searching..."); 1308 1308 1309 1309 spt_t sp, producer_pos; 1310 1310 tag_get_pt(&pane.caret_pos, &sp); 1311 1311 1312 1312 /* Start searching on the position before/after caret */ 1313 1313 if (!reverse) { … … 1318 1318 } 1319 1319 producer_pos = sp; 1320 1320 1321 1321 search_ops_t ops = search_spt_ops; 1322 1322 if (reverse) 1323 1323 ops = search_spt_reverse_ops; 1324 1324 1325 1325 search_t *search = search_init(pattern, &producer_pos, ops, reverse); 1326 1326 if (search == NULL) { … … 1328 1328 return; 1329 1329 } 1330 1330 1331 1331 match_t match; 1332 1332 errno_t rc = search_next_match(search, &match); … … 1335 1335 search_fini(search); 1336 1336 } 1337 1337 1338 1338 if (match.end) { 1339 1339 status_display("Match found."); … … 1356 1356 status_display("Not found."); 1357 1357 } 1358 1358 1359 1359 search_fini(search); 1360 1360 } … … 1649 1649 console_set_pos(con, 0, scr_rows - 1); 1650 1650 console_set_style(con, STYLE_INVERTED); 1651 1651 1652 1652 int pos = -(scr_columns - 3); 1653 1653 printf(" %*s ", pos, str); -
uspace/dist/src/c/demos/edit/search.c
r3061bc1 ra35b458 48 48 if (search == NULL) 49 49 return NULL; 50 50 51 51 wchar_t *p = str_to_awstr(pattern); 52 52 if (p == NULL) { … … 54 54 return NULL; 55 55 } 56 56 57 57 search->pattern_length = wstr_length(p); 58 58 59 59 if (reverse) { 60 60 /* Reverse the pattern */ … … 67 67 } 68 68 } 69 69 70 70 search->pattern = p; 71 71 72 72 search->client_data = client_data; 73 73 search->ops = ops; … … 78 78 return NULL; 79 79 } 80 80 81 81 search->pattern_pos = 0; 82 82 83 83 search->back_table[0] = -1; 84 84 search->back_table[1] = 0; … … 100 100 } 101 101 } 102 102 103 103 return search; 104 104 } … … 107 107 { 108 108 search_equals_fn eq = s->ops.equals; 109 109 110 110 wchar_t cur_char; 111 111 errno_t rc = EOK; … … 128 128 } 129 129 } 130 130 131 131 match->end = NULL; 132 132 match->length = 0; 133 133 134 134 return rc; 135 135 } … … 139 139 free(search->pattern); 140 140 free(search->back_table); 141 141 142 142 } 143 143 -
uspace/dist/src/c/demos/edit/sheet.c
r3061bc1 ra35b458 263 263 coord.row = row; 264 264 coord.column = 65536; 265 265 266 266 sheet_get_cell_pt(sh, &coord, dir_before, &pt); 267 267 spt_get_coord(&pt, &coord); -
uspace/dist/src/c/demos/tetris/scores.c
r3061bc1 ra35b458 99 99 { 100 100 int i; 101 101 102 102 clear_screen(); 103 103 moveto(10, 0); 104 104 printf("\tRank \tLevel \tName\t points\n"); 105 105 printf("\t========================================================\n"); 106 106 107 107 for (i = 0; i < NUMSPOTS - 1; i++) 108 108 printf("\t%6d %6d %-16s %20d\n", 109 109 i + 1, scores[i].hs_level, scores[i].hs_name, scores[i].hs_score); 110 110 111 111 if (!firstgame) { 112 112 printf("\t========================================================\n"); … … 114 114 scores[NUMSPOTS - 1].hs_level, scores[NUMSPOTS - 1].hs_name, scores[NUMSPOTS - 1].hs_score); 115 115 } 116 116 117 117 printf("\n\n\n\n\tPress any key to return to main menu."); 118 118 getchar(); … … 126 126 cons_event_t ev; 127 127 kbd_event_t *kev; 128 128 129 129 clear_screen(); 130 130 moveto(10, 10); … … 134 134 i = 6; 135 135 off = 6; 136 136 137 137 moveto(10 , 28); 138 138 printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME-i, 139 139 "........................................"); 140 140 141 141 while (1) { 142 142 console_flush(console); 143 143 if (!console_get_event(console, &ev)) 144 144 exit(1); 145 145 146 146 if (ev.type != CEV_KEY || ev.ev.key.type == KEY_RELEASE) 147 147 continue; 148 148 149 149 kev = &ev.ev.key; 150 150 151 151 if (kev->key == KC_ENTER || kev->key == KC_NENTER) 152 152 break; 153 153 154 154 if (kev->key == KC_BACKSPACE) { 155 155 if (i > 0) { 156 156 wchar_t uc; 157 157 158 158 --i; 159 159 while (off > 0) { … … 165 165 break; 166 166 } 167 167 168 168 scores[NUMSPOTS - 1].hs_name[off] = '\0'; 169 169 } … … 177 177 } 178 178 } 179 179 180 180 moveto(10, 28); 181 181 printf("%s%.*s", scores[NUMSPOTS - 1].hs_name, MAXLOGNAME - i, 182 182 "........................................"); 183 183 } 184 184 185 185 scores[NUMSPOTS - 1].hs_score = score; 186 186 scores[NUMSPOTS - 1].hs_level = level; 187 187 188 188 i = NUMSPOTS - 1; 189 189 while ((i > 0) && (scores[i - 1].hs_score < score)) 190 190 i--; 191 191 192 192 for (j = NUMSPOTS - 2; j > i; j--) 193 193 copyhiscore(j, j-1); 194 194 195 195 copyhiscore(i, NUMSPOTS - 1); 196 196 } … … 236 236 return; 237 237 } 238 238 239 239 cnt = fwrite(scores, sizeof(struct highscore), NUMSPOTS, f); 240 240 rc = fclose(f); -
uspace/dist/src/c/demos/tetris/screen.c
r3061bc1 ra35b458 148 148 sysarg_t ccap; 149 149 errno_t rc = console_get_color_cap(console, &ccap); 150 150 151 151 if (rc != EOK) 152 152 return false; 153 153 154 154 return ((ccap & CONSOLE_CAP_RGB) == CONSOLE_CAP_RGB); 155 155 } … … 161 161 { 162 162 winsize_t ws; 163 163 164 164 Rows = 0; 165 165 Cols = 0; 166 166 167 167 if (get_display_size(&ws) == 0) { 168 168 Rows = ws.ws_row; … … 171 171 172 172 use_color = get_display_color_sup(); 173 173 174 174 if ((Rows < MINROWS) || (Cols < MINCOLS)) { 175 175 char smallscr[55]; 176 176 177 177 snprintf(smallscr, sizeof(smallscr), 178 178 "the screen is too small (must be at least %dx%d)", … … 181 181 } 182 182 isset = 1; 183 183 184 184 scr_clear(); 185 185 } … … 197 197 if (isset) 198 198 scr_end(); 199 199 200 200 errx(1, "aborting: %s", why); 201 201 } … … 213 213 int j; 214 214 int ccol; 215 215 216 216 /* Always leave cursor after last displayed point */ 217 217 curscreen[D_LAST * B_COLS - 1] = -1; 218 218 219 219 if (score != curscore) { 220 220 moveto(0, 0); … … 222 222 curscore = score; 223 223 } 224 224 225 225 /* Draw preview of next pattern */ 226 226 if ((showpreview) && (nextshape != lastshape)) { … … 228 228 static int r = 5, c = 2; 229 229 int tr, tc, t; 230 230 231 231 lastshape = nextshape; 232 232 233 233 /* Clean */ 234 234 resume_normal(); … … 241 241 moveto(r + 2, c - 1); 242 242 putstr(" "); 243 243 244 244 moveto(r - 3, c - 2); 245 245 putstr("Next shape:"); 246 246 247 247 /* Draw */ 248 248 start_standout(nextshape->color); … … 252 252 t = c + r * B_COLS; 253 253 t += nextshape->off[i]; 254 254 255 255 tr = t / B_COLS; 256 256 tc = t % B_COLS; 257 257 258 258 moveto(tr, 2*tc); 259 259 putstr(" "); … … 261 261 resume_normal(); 262 262 } 263 263 264 264 bp = &board[D_FIRST * B_COLS]; 265 265 sp = &curscreen[D_FIRST * B_COLS]; … … 269 269 if (*sp == (so = *bp)) 270 270 continue; 271 271 272 272 *sp = so; 273 273 if (i != ccol) { … … 278 278 moveto(RTOD(j), CTOD(i)); 279 279 } 280 280 281 281 if (so != cur_so) { 282 282 if (so) … … 287 287 } 288 288 putstr(" "); 289 289 290 290 ccol = i + 1; 291 291 /* … … 297 297 * the next cell is a different color. 298 298 */ 299 299 300 300 if ((i > STOP) || (sp[1] != bp[1]) || (so != bp[1])) 301 301 continue; 302 302 303 303 if (sp[2] != bp[2]) 304 304 sp[1] = -1; … … 309 309 } 310 310 } 311 311 312 312 if (cur_so) 313 313 resume_normal(); 314 314 315 315 console_flush(console); 316 316 } … … 323 323 { 324 324 int l = str_size(s); 325 325 326 326 moveto(Rows - 2, ((Cols - l) >> 1) - 1); 327 327 328 328 if (set) 329 329 putstr(s); … … 341 341 { 342 342 suseconds_t timeout = fallrate; 343 343 344 344 while (timeout > 0) { 345 345 cons_event_t event; 346 346 347 347 if (!console_get_event_timeout(console, &event, &timeout)) 348 348 break; … … 359 359 * and increase speed. 360 360 */ 361 361 362 362 if (timeleft <= 0) { 363 363 faster(); 364 364 timeleft = fallrate; 365 365 } 366 366 367 367 /* 368 368 * Wait to see if there is any input. If so, take it and … … 371 371 * make timeleft zero and return -1. 372 372 */ 373 373 374 374 wchar_t c = 0; 375 375 376 376 while (c == 0) { 377 377 cons_event_t event; 378 378 379 379 if (!console_get_event_timeout(console, &event, &timeleft)) { 380 380 timeleft = 0; 381 381 return -1; 382 382 } 383 383 384 384 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS) 385 385 c = event.ev.key.c; 386 386 } 387 387 388 388 return (int) c; 389 389 } … … 395 395 { 396 396 wchar_t c = 0; 397 397 398 398 while (c == 0) { 399 399 cons_event_t event; 400 400 401 401 if (!console_get_event(console, &event)) 402 402 return -1; 403 403 404 404 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS) 405 405 c = event.ev.key.c; 406 406 } 407 407 408 408 return (int) c; 409 409 } -
uspace/dist/src/c/demos/tetris/shapes.c
r3061bc1 ra35b458 96 96 { 97 97 const int *o = shape->off; 98 98 99 99 if ((board[pos]) || (board[pos + *o++]) || (board[pos + *o++]) || 100 100 (board[pos + *o])) 101 101 return 0; 102 102 103 103 return 1; 104 104 } … … 111 111 { 112 112 const int *o = shape->off; 113 113 114 114 board[pos] = onoff ? shape->color : 0x000000; 115 115 board[pos + *o++] = onoff ? shape->color : 0x000000; -
uspace/dist/src/c/demos/tetris/tetris.c
r3061bc1 ra35b458 98 98 int i; 99 99 cell *p = board; 100 100 101 101 for (i = B_SIZE; i; i--) 102 102 *p++ = (i <= (2 * B_COLS) || (i % B_COLS) < 2) ? 0x0000ff : 0x000000; … … 113 113 int base; 114 114 cell *p; 115 115 116 116 for (i = A_FIRST; i < A_LAST; i++) { 117 117 base = i * B_COLS + 1; … … 122 122 rows++; 123 123 memset(&board[base], 0, sizeof(cell) * (B_COLS - 2)); 124 124 125 125 scr_update(); 126 126 tsleep(); 127 127 128 128 while (--base != 0) 129 129 board[base + B_COLS] = board[base]; 130 130 131 131 scr_update(); 132 132 tsleep(); 133 133 134 134 break; 135 135 } 136 136 } 137 137 } 138 138 139 139 switch (rows) { 140 140 case 1: … … 160 160 int i; 161 161 int j = rand() % 4; 162 162 163 163 for (i = 0; i < j; i++) 164 164 tmp = &shapes[classic ? tmp->rotc : tmp->rot]; 165 165 166 166 return (tmp); 167 167 } … … 170 170 { 171 171 struct timeval tv; 172 172 173 173 gettimeofday(&tv, NULL); 174 174 srand(tv.tv_sec + tv.tv_usec / 100000); … … 180 180 moveto(5, 10); 181 181 puts("Tetris\n\n"); 182 182 183 183 moveto(8, 10); 184 184 printf("Level = %d (press keys 1 - 9 to change)", level); … … 202 202 while (1) { 203 203 int i = getchar(); 204 204 205 205 switch(i) { 206 206 case 'p': … … 249 249 int j; 250 250 int ch; 251 251 252 252 console = console_init(stdin, stdout); 253 253 254 254 keys = "jkl pq"; 255 255 256 256 classic = 0; 257 257 showpreview = 1; 258 258 259 259 while ((ch = getopt(argc, argv, "ck:ps")) != -1) 260 260 switch(ch) { … … 280 280 usage(); 281 281 } 282 282 283 283 argc -= optind; 284 284 argv += optind; 285 285 286 286 if (argc) 287 287 usage(); 288 288 289 289 for (i = 0; i <= 5; i++) { 290 290 for (j = i + 1; j <= 5; j++) { … … 292 292 errx(1, "%s", "duplicate command keys specified."); 293 293 } 294 294 295 295 if (keys[i] == ' ') 296 296 str_cpy(key_write[i], sizeof(key_write[i]), "<space>"); … … 300 300 } 301 301 } 302 302 303 303 snprintf(key_msg, sizeof(key_msg), 304 304 "%s - left %s - rotate %s - right %s - drop %s - pause %s - quit", 305 305 key_write[0], key_write[1], key_write[2], key_write[3], 306 306 key_write[4], key_write[5]); 307 307 308 308 scr_init(); 309 309 if (loadscores() != EOK) … … 312 312 while (tetris_menu(&level)) { 313 313 fallrate = 1000000 / level; 314 314 315 315 scr_clear(); 316 316 setup_board(); 317 317 318 318 srandomdev(); 319 319 scr_set(); 320 320 321 321 pos = A_FIRST * B_COLS + (B_COLS / 2) - 1; 322 322 nextshape = randshape(); 323 323 curshape = randshape(); 324 324 325 325 scr_msg(key_msg, 1); 326 326 327 327 while (1) { 328 328 place(curshape, pos, 1); … … 338 338 continue; 339 339 } 340 340 341 341 /* 342 342 * Put up the current shape `permanently', … … 346 346 score++; 347 347 elide(); 348 348 349 349 /* 350 350 * Choose a new shape. If it does not fit, … … 354 354 nextshape = randshape(); 355 355 pos = A_FIRST * B_COLS + (B_COLS / 2) - 1; 356 356 357 357 if (!fits_in(curshape, pos)) 358 358 break; 359 360 continue; 361 } 362 359 360 continue; 361 } 362 363 363 /* 364 364 * Handle command keys. … … 368 368 break; 369 369 } 370 370 371 371 if (c == keys[4]) { 372 372 static char msg[] = 373 373 "paused - press RETURN to continue"; 374 374 375 375 place(curshape, pos, 1); 376 376 do { … … 380 380 console_flush(console); 381 381 } while (!twait()); 382 382 383 383 scr_msg(msg, 0); 384 384 scr_msg(key_msg, 1); … … 386 386 continue; 387 387 } 388 388 389 389 if (c == keys[0]) { 390 390 /* move left */ … … 393 393 continue; 394 394 } 395 395 396 396 if (c == keys[1]) { 397 397 /* turn */ 398 398 const struct shape *new = 399 399 &shapes[classic ? curshape->rotc : curshape->rot]; 400 400 401 401 if (fits_in(new, pos)) 402 402 curshape = new; 403 403 continue; 404 404 } 405 405 406 406 if (c == keys[2]) { 407 407 /* move right */ … … 410 410 continue; 411 411 } 412 412 413 413 if (c == keys[3]) { 414 414 /* move to bottom */ … … 419 419 continue; 420 420 } 421 421 422 422 if (c == '\f') { 423 423 scr_clear(); … … 425 425 } 426 426 } 427 427 428 428 scr_clear(); 429 429 loadscores(); … … 432 432 score = 0; 433 433 } 434 434 435 435 scr_clear(); 436 436 printf("\nGame over.\n"); 437 437 scr_end(); 438 438 439 439 return 0; 440 440 } -
uspace/dist/src/c/demos/top/screen.c
r3061bc1 ra35b458 98 98 { 99 99 screen_style_normal(); 100 100 101 101 if (clear) { 102 102 console_flush(console); 103 103 console_clear(console); 104 104 } 105 105 106 106 screen_moveto(0, 0); 107 107 } … … 112 112 sysarg_t rows; 113 113 screen_get_size(&cols, &rows); 114 114 115 115 sysarg_t c; 116 116 sysarg_t r; 117 117 screen_get_pos(&c, &r); 118 118 119 119 sysarg_t i; 120 120 for (i = c + 1; i < cols; i++) 121 121 puts(" "); 122 122 123 123 if (r + 1 < rows) 124 124 puts("\n"); … … 128 128 { 129 129 console = console_init(stdin, stdout); 130 130 131 131 console_flush(console); 132 132 console_cursor_visibility(console, false); 133 133 134 134 screen_restart(true); 135 135 } … … 141 141 142 142 screen_restart(true); 143 143 144 144 console_flush(console); 145 145 console_cursor_visibility(console, true); … … 149 149 { 150 150 printf("%3" PRIu64 ".", ffloat.upper / ffloat.lower); 151 151 152 152 unsigned int i; 153 153 uint64_t rest = (ffloat.upper % ffloat.lower) * 10; … … 156 156 rest = (rest % ffloat.lower) * 10; 157 157 } 158 158 159 159 printf("%%"); 160 160 } … … 165 165 sysarg_t rows; 166 166 screen_get_size(&cols, &rows); 167 167 168 168 sysarg_t c; 169 169 sysarg_t r; 170 170 screen_get_pos(&c, &r); 171 171 172 172 if (c < cols) { 173 173 int pos = cols - c - 1; … … 183 183 data->hours, data->minutes, data->seconds, 184 184 data->udays, data->uhours, data->uminutes, data->useconds); 185 185 186 186 size_t i; 187 187 for (i = 0; i < data->load_count; i++) { … … 189 189 stats_print_load_fragment(data->load[i], 2); 190 190 } 191 191 192 192 screen_newline(); 193 193 } … … 208 208 size_t other = 0; 209 209 size_t invalid = 0; 210 210 211 211 size_t i; 212 212 for (i = 0; i < data->threads_count; i++) { 213 213 total++; 214 214 215 215 switch (data->threads[i].state) { 216 216 case Running: … … 234 234 } 235 235 } 236 236 237 237 printf("threads: %zu total, %zu running, %zu ready, " 238 238 "%zu sleeping, %zu lingering, %zu other, %zu invalid", … … 250 250 char busy_suffix; 251 251 char idle_suffix; 252 252 253 253 order_suffix(data->cpus[i].busy_cycles, &busy, &busy_suffix); 254 254 order_suffix(data->cpus[i].idle_cycles, &idle, &idle_suffix); 255 255 256 256 printf("cpu%u (%4" PRIu16 " MHz): busy cycles: " 257 257 "%" PRIu64 "%c, idle cycles: %" PRIu64 "%c", … … 264 264 } else 265 265 printf("cpu%u inactive", data->cpus[i].id); 266 266 267 267 screen_newline(); 268 268 } … … 279 279 const char *used_suffix; 280 280 const char *free_suffix; 281 281 282 282 bin_order_suffix(data->physmem->total, &total, &total_suffix, false); 283 283 bin_order_suffix(data->physmem->unavail, &unavail, &unavail_suffix, false); 284 284 bin_order_suffix(data->physmem->used, &used, &used_suffix, false); 285 285 bin_order_suffix(data->physmem->free, &free, &free_suffix, false); 286 286 287 287 printf("memory: %" PRIu64 "%s total, %" PRIu64 "%s unavail, %" 288 288 PRIu64 "%s used, %" PRIu64 "%s free", total, total_suffix, … … 304 304 sysarg_t rows; 305 305 screen_get_size(&cols, &rows); 306 307 screen_newline(); 308 306 307 screen_newline(); 308 309 309 printf("Operation modes:"); 310 310 screen_newline(); 311 311 312 312 printf(" t .. tasks statistics"); 313 313 screen_newline(); 314 314 315 315 printf(" i .. IPC statistics"); 316 316 screen_newline(); 317 317 318 318 printf(" e .. exceptions statistics"); 319 319 screen_newline(); 320 320 321 321 printf(" a .. toggle display of all/hot exceptions"); 322 322 screen_newline(); … … 329 329 printf("Other keys:"); 330 330 screen_newline(); 331 331 332 332 printf(" s .. choose column to sort by"); 333 333 screen_newline(); 334 334 335 335 printf(" r .. toggle reversed sorting"); 336 336 screen_newline(); 337 337 338 338 printf(" q .. quit"); 339 339 screen_newline(); 340 340 341 341 sysarg_t col; 342 342 sysarg_t row; 343 343 screen_get_pos(&col, &row); 344 344 345 345 while (row < rows) { 346 346 screen_newline(); … … 379 379 sysarg_t rows; 380 380 screen_get_size(&cols, &rows); 381 381 382 382 sysarg_t col; 383 383 sysarg_t row; 384 384 screen_get_pos(&col, &row); 385 385 386 386 size_t i; 387 387 for (i = 0; (i < table->num_fields) && (row < rows); i++) { … … 440 440 } 441 441 } 442 442 443 443 while (row < rows) { 444 444 screen_newline(); … … 452 452 sysarg_t rows; 453 453 screen_get_size(&cols, &rows); 454 454 455 455 sysarg_t col; 456 456 sysarg_t row; … … 463 463 row++; 464 464 } 465 465 466 466 while (row < rows) { 467 467 screen_newline(); … … 493 493 print_physmem_info(data); 494 494 print_warning(); 495 495 496 496 switch (screen_mode) { 497 497 case SCREEN_TABLE: … … 506 506 print_help(); 507 507 } 508 508 509 509 console_flush(console); 510 510 } … … 526 526 vsnprintf(warning_text, warning_text_size, fmt, args); 527 527 va_end(args); 528 528 529 529 warning_timeleft = 2 * USEC_COUNT; 530 530 … … 542 542 * Reset timeleft whenever it is not positive. 543 543 */ 544 544 545 545 if (timeleft <= 0) 546 546 timeleft = sec * USEC_COUNT; 547 547 548 548 /* 549 549 * Wait to see if there is any input. If so, take it and … … 552 552 * make timeleft zero and return -1. 553 553 */ 554 554 555 555 wchar_t c = 0; 556 556 557 557 while (c == 0) { 558 558 cons_event_t event; 559 559 560 560 warning_timeleft -= timeleft; 561 561 if (!console_get_event_timeout(console, &event, &timeleft)) { … … 564 564 } 565 565 warning_timeleft += timeleft; 566 566 567 567 if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS) 568 568 c = event.ev.key.c; 569 569 } 570 570 571 571 return (int) c; 572 572 } -
uspace/dist/src/c/demos/top/top.c
r3061bc1 ra35b458 152 152 target->table.num_fields = 0; 153 153 target->table.fields = NULL; 154 154 155 155 /* Get current time */ 156 156 struct timeval time; 157 157 gettimeofday(&time, NULL); 158 158 159 159 target->hours = (time.tv_sec % DAY) / HOUR; 160 160 target->minutes = (time.tv_sec % HOUR) / MINUTE; 161 161 target->seconds = time.tv_sec % MINUTE; 162 162 163 163 /* Get uptime */ 164 164 struct timeval uptime; 165 165 getuptime(&uptime); 166 166 167 167 target->udays = uptime.tv_sec / DAY; 168 168 target->uhours = (uptime.tv_sec % DAY) / HOUR; 169 169 target->uminutes = (uptime.tv_sec % HOUR) / MINUTE; 170 170 target->useconds = uptime.tv_sec % MINUTE; 171 171 172 172 /* Get load */ 173 173 target->load = stats_get_load(&(target->load_count)); 174 174 if (target->load == NULL) 175 175 return "Cannot get system load"; 176 176 177 177 /* Get CPUs */ 178 178 target->cpus = stats_get_cpus(&(target->cpus_count)); 179 179 if (target->cpus == NULL) 180 180 return "Cannot get CPUs"; 181 181 182 182 target->cpus_perc = 183 183 (perc_cpu_t *) calloc(target->cpus_count, sizeof(perc_cpu_t)); 184 184 if (target->cpus_perc == NULL) 185 185 return "Not enough memory for CPU utilization"; 186 186 187 187 /* Get tasks */ 188 188 target->tasks = stats_get_tasks(&(target->tasks_count)); 189 189 if (target->tasks == NULL) 190 190 return "Cannot get tasks"; 191 191 192 192 target->tasks_perc = 193 193 (perc_task_t *) calloc(target->tasks_count, sizeof(perc_task_t)); 194 194 if (target->tasks_perc == NULL) 195 195 return "Not enough memory for task utilization"; 196 196 197 197 /* Get threads */ 198 198 target->threads = stats_get_threads(&(target->threads_count)); 199 199 if (target->threads == NULL) 200 200 return "Cannot get threads"; 201 201 202 202 /* Get Exceptions */ 203 203 target->exceptions = stats_get_exceptions(&(target->exceptions_count)); 204 204 if (target->exceptions == NULL) 205 205 return "Cannot get exceptions"; 206 206 207 207 target->exceptions_perc = 208 208 (perc_exc_t *) calloc(target->exceptions_count, sizeof(perc_exc_t)); 209 209 if (target->exceptions_perc == NULL) 210 210 return "Not enough memory for exception utilization"; 211 211 212 212 /* Get physical memory */ 213 213 target->physmem = stats_get_physmem(); 214 214 if (target->physmem == NULL) 215 215 return "Cannot get physical memory"; 216 216 217 217 target->ucycles_diff = calloc(target->tasks_count, 218 218 sizeof(uint64_t)); 219 219 if (target->ucycles_diff == NULL) 220 220 return "Not enough memory for user utilization"; 221 221 222 222 /* Allocate memory for computed values */ 223 223 target->kcycles_diff = calloc(target->tasks_count, … … 225 225 if (target->kcycles_diff == NULL) 226 226 return "Not enough memory for kernel utilization"; 227 227 228 228 target->ecycles_diff = calloc(target->exceptions_count, 229 229 sizeof(uint64_t)); 230 230 if (target->ecycles_diff == NULL) 231 231 return "Not enough memory for exception cycles utilization"; 232 232 233 233 target->ecount_diff = calloc(target->exceptions_count, 234 234 sizeof(uint64_t)); 235 235 if (target->ecount_diff == NULL) 236 236 return "Not enough memory for exception count utilization"; 237 237 238 238 return NULL; 239 239 } … … 249 249 /* For each CPU: Compute total cycles and divide it between 250 250 user and kernel */ 251 251 252 252 size_t i; 253 253 for (i = 0; i < new_data->cpus_count; i++) { … … 257 257 new_data->cpus[i].busy_cycles - old_data->cpus[i].busy_cycles; 258 258 uint64_t sum = idle + busy; 259 259 260 260 FRACTION_TO_FLOAT(new_data->cpus_perc[i].idle, idle * 100, sum); 261 261 FRACTION_TO_FLOAT(new_data->cpus_perc[i].busy, busy * 100, sum); 262 262 } 263 263 264 264 /* For all tasks compute sum and differencies of all cycles */ 265 265 266 266 uint64_t virtmem_total = 0; 267 267 uint64_t resmem_total = 0; 268 268 uint64_t ucycles_total = 0; 269 269 uint64_t kcycles_total = 0; 270 270 271 271 for (i = 0; i < new_data->tasks_count; i++) { 272 272 /* Match task with the previous instance */ 273 273 274 274 bool found = false; 275 275 size_t j; … … 280 280 } 281 281 } 282 282 283 283 if (!found) { 284 284 /* This is newly borned task, ignore it */ … … 287 287 continue; 288 288 } 289 289 290 290 new_data->ucycles_diff[i] = 291 291 new_data->tasks[i].ucycles - old_data->tasks[j].ucycles; 292 292 new_data->kcycles_diff[i] = 293 293 new_data->tasks[i].kcycles - old_data->tasks[j].kcycles; 294 294 295 295 virtmem_total += new_data->tasks[i].virtmem; 296 296 resmem_total += new_data->tasks[i].resmem; … … 298 298 kcycles_total += new_data->kcycles_diff[i]; 299 299 } 300 300 301 301 /* For each task compute percential change */ 302 302 303 303 for (i = 0; i < new_data->tasks_count; i++) { 304 304 FRACTION_TO_FLOAT(new_data->tasks_perc[i].virtmem, … … 311 311 new_data->kcycles_diff[i] * 100, kcycles_total); 312 312 } 313 313 314 314 /* For all exceptions compute sum and differencies of cycles */ 315 315 316 316 uint64_t ecycles_total = 0; 317 317 uint64_t ecount_total = 0; 318 318 319 319 for (i = 0; i < new_data->exceptions_count; i++) { 320 320 /* … … 323 323 * usually disappear, but it does not hurt. 324 324 */ 325 325 326 326 bool found = false; 327 327 size_t j; … … 332 332 } 333 333 } 334 334 335 335 if (!found) { 336 336 /* This is a new exception, ignore it */ … … 339 339 continue; 340 340 } 341 341 342 342 new_data->ecycles_diff[i] = 343 343 new_data->exceptions[i].cycles - old_data->exceptions[j].cycles; 344 344 new_data->ecount_diff[i] = 345 345 new_data->exceptions[i].count - old_data->exceptions[i].count; 346 346 347 347 ecycles_total += new_data->ecycles_diff[i]; 348 348 ecount_total += new_data->ecount_diff[i]; 349 349 } 350 350 351 351 /* For each exception compute percential change */ 352 352 353 353 for (i = 0; i < new_data->exceptions_count; i++) { 354 354 FRACTION_TO_FLOAT(new_data->exceptions_perc[i].cycles, … … 363 363 field_t *fa = (field_t *)a + sort_column; 364 364 field_t *fb = (field_t *)b + sort_column; 365 365 366 366 if (fa->type > fb->type) 367 367 return 1 * sort_reverse; … … 535 535 if (target->load != NULL) 536 536 free(target->load); 537 537 538 538 if (target->cpus != NULL) 539 539 free(target->cpus); 540 540 541 541 if (target->cpus_perc != NULL) 542 542 free(target->cpus_perc); 543 543 544 544 if (target->tasks != NULL) 545 545 free(target->tasks); 546 546 547 547 if (target->tasks_perc != NULL) 548 548 free(target->tasks_perc); 549 549 550 550 if (target->threads != NULL) 551 551 free(target->threads); 552 552 553 553 if (target->exceptions != NULL) 554 554 free(target->exceptions); 555 555 556 556 if (target->exceptions_perc != NULL) 557 557 free(target->exceptions_perc); 558 558 559 559 if (target->physmem != NULL) 560 560 free(target->physmem); 561 561 562 562 if (target->ucycles_diff != NULL) 563 563 free(target->ucycles_diff); 564 564 565 565 if (target->kcycles_diff != NULL) 566 566 free(target->kcycles_diff); 567 567 568 568 if (target->ecycles_diff != NULL) 569 569 free(target->ecycles_diff); 570 570 571 571 if (target->ecount_diff != NULL) 572 572 free(target->ecount_diff); … … 581 581 data_t data_prev; 582 582 const char *ret = NULL; 583 583 584 584 screen_init(); 585 585 printf("Reading initial data...\n"); 586 586 587 587 if ((ret = read_data(&data)) != NULL) 588 588 goto out; 589 589 590 590 /* Compute some rubbish to have initialised values */ 591 591 compute_percentages(&data, &data); 592 592 593 593 /* And paint screen until death */ 594 594 while (true) { … … 601 601 goto out; 602 602 } 603 603 604 604 compute_percentages(&data_prev, &data); 605 605 free_data(&data_prev); … … 671 671 print_data(&data); 672 672 } 673 673 674 674 out: 675 675 screen_done(); 676 676 free_data(&data); 677 677 678 678 if (ret != NULL) { 679 679 fprintf(stderr, "%s: %s\n", NAME, ret); 680 680 return 1; 681 681 } 682 682 683 683 return 0; 684 684 } -
uspace/dist/src/c/demos/top/top.h
r3061bc1 ra35b458 112 112 time_t minutes; 113 113 time_t seconds; 114 114 115 115 sysarg_t udays; 116 116 sysarg_t uhours; 117 117 sysarg_t uminutes; 118 118 sysarg_t useconds; 119 119 120 120 size_t load_count; 121 121 load_t *load; 122 122 123 123 size_t cpus_count; 124 124 stats_cpu_t *cpus; 125 125 perc_cpu_t *cpus_perc; 126 126 127 127 size_t tasks_count; 128 128 stats_task_t *tasks; 129 129 perc_task_t *tasks_perc; 130 130 131 131 size_t threads_count; 132 132 stats_thread_t *threads; 133 133 134 134 size_t exceptions_count; 135 135 stats_exc_t *exceptions; 136 136 perc_exc_t *exceptions_perc; 137 137 138 138 stats_physmem_t *physmem; 139 139 140 140 uint64_t *ucycles_diff; 141 141 uint64_t *kcycles_diff;
Note:
See TracChangeset
for help on using the changeset viewer.
