2 * Copyright (C) 2011-2012 Julien Desfossez
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 #include <semaphore.h>
27 #include "cursesdisplay.h"
28 #include "lttngtoptypes.h"
29 #include "iostreamtop.h"
32 #define DEFAULT_DELAY 15
33 #define MAX_LINE_LENGTH 50
34 #define MAX_LOG_LINES 4
36 /* to prevent concurrent updates of the different windows */
37 sem_t update_display_sem
;
40 WINDOW
*footer
, *header
, *center
, *status
;
41 WINDOW
*pref_panel_window
= NULL
;
42 PANEL
*pref_panel
, *main_panel
;
44 int pref_panel_visible
= 0;
45 int pref_line_selected
= 0;
46 int pref_current_sort
= 0;
48 int last_display_index
, currently_displayed_index
;
50 struct processtop
*selected_process
= NULL
;
53 int selected_line
= 0; /* select bar position */
54 int selected_in_list
= 0; /* selection relative to the whole list */
55 int list_offset
= 0; /* first index in the list to display (scroll) */
57 char log_lines
[MAX_LINE_LENGTH
* MAX_LOG_LINES
+ MAX_LOG_LINES
];
59 int max_elements
= 80;
61 int toggle_threads
= 1;
62 int toggle_pause
= -1;
65 GPtrArray
*selected_processes
;
67 pthread_t keyboard_thread
;
69 struct header_view cputopview
[4];
70 struct header_view iostreamtopview
[3];
71 struct header_view fileview
[3];
80 static void handle_sigterm(int signal
)
89 halfdelay(DEFAULT_DELAY
);
91 intrflush(stdscr
, false);
97 init_pair(1, COLOR_RED
, COLOR_BLACK
); /* - */
98 init_pair(2, COLOR_GREEN
, COLOR_BLACK
); /* + */
99 init_pair(3, COLOR_BLACK
, COLOR_WHITE
); /* keys */
100 init_pair(4, COLOR_WHITE
, COLOR_GREEN
); /* keys activated */
101 init_pair(5, COLOR_WHITE
, COLOR_BLUE
); /* select line */
102 init_pair(6, COLOR_WHITE
, COLOR_GREEN
); /* selected process */
104 termtype
= getenv("TERM");
105 if (!strcmp(termtype
, "xterm") || !strcmp(termtype
, "xterm-color") ||
106 !strcmp(termtype
, "vt220")) {
107 define_key("\033[H", KEY_HOME
);
108 define_key("\033[F", KEY_END
);
109 define_key("\033OP", KEY_F(1));
110 define_key("\033OQ", KEY_F(2));
111 define_key("\033OR", KEY_F(3));
112 define_key("\033OS", KEY_F(4));
113 define_key("\0330U", KEY_F(6));
114 define_key("\033[11~", KEY_F(1));
115 define_key("\033[12~", KEY_F(2));
116 define_key("\033[13~", KEY_F(3));
117 define_key("\033[14~", KEY_F(4));
118 define_key("\033[16~", KEY_F(6));
119 define_key("\033[17;2~", KEY_F(18));
121 signal(SIGTERM
, handle_sigterm
);
122 mousemask(BUTTON1_CLICKED
, NULL
);
126 WINDOW
*create_window(int height
, int width
, int startx
, int starty
)
129 win
= newwin(height
, width
, startx
, starty
);
135 WINDOW
*create_window_no_border(int height
, int width
, int startx
, int starty
)
138 win
= newwin(height
, width
, startx
, starty
);
143 void print_digit(WINDOW
*win
, int digit
)
146 wattron(win
, COLOR_PAIR(1));
147 wprintw(win
, "%d", digit
);
148 wattroff(win
, COLOR_PAIR(1));
149 } else if (digit
> 0) {
150 wattron(win
, COLOR_PAIR(2));
151 wprintw(win
, "+%d", digit
);
152 wattroff(win
, COLOR_PAIR(2));
158 void print_digits(WINDOW
*win
, int first
, int second
)
161 print_digit(win
, first
);
163 print_digit(win
, second
);
167 void print_headers(int line
, char *desc
, int value
, int first
, int second
)
169 wattron(header
, A_BOLD
);
170 mvwprintw(header
, line
, 4, "%s", desc
);
171 wattroff(header
, A_BOLD
);
172 mvwprintw(header
, line
, 16, "%d", value
);
173 wmove(header
, line
, 24);
174 print_digits(header
, first
, second
);
175 wmove(header
, line
, 40);
178 void set_window_title(WINDOW
*win
, char *title
)
180 wattron(win
, A_BOLD
);
181 mvwprintw(win
, 0, 1, title
);
182 wattroff(win
, A_BOLD
);
185 void print_log(char *str
)
188 int current_line
= 1;
189 int current_char
= 1;
191 /* rotate the line buffer */
192 if (nb_log_lines
>= MAX_LOG_LINES
) {
193 tmp
= strndup(log_lines
, MAX_LINE_LENGTH
* MAX_LOG_LINES
+ MAX_LOG_LINES
);
194 tmp2
= strchr(tmp
, '\n');
195 memset(log_lines
, '\0', strlen(log_lines
));
196 strncat(log_lines
, tmp2
+ 1, strlen(tmp2
) - 1);
197 log_lines
[strlen(log_lines
)] = '\n';
198 log_lines
[strlen(log_lines
)] = '\0';
203 strncat(log_lines
, str
, MAX_LINE_LENGTH
- 1);
205 if (nb_log_lines
< MAX_LOG_LINES
)
206 log_lines
[strlen(log_lines
)] = '\n';
207 log_lines
[strlen(log_lines
)] = '\0';
211 set_window_title(status
, "Status");
212 for (i
= 0; i
< strlen(log_lines
); i
++) {
213 if (log_lines
[i
] == '\n') {
214 wmove(status
, ++current_line
, 1);
217 mvwprintw(status
, current_line
, current_char
++, "%c",
224 int process_selected(struct processtop
*process
)
227 struct processtop
*stored_process
;
229 for (i
= 0; i
< selected_processes
->len
; i
++) {
230 stored_process
= g_ptr_array_index(selected_processes
, i
);
233 if (stored_process
->tid
== process
->tid
)
239 void update_selected_processes()
242 struct processtop
*stored_process
;
244 if (process_selected(selected_process
)) {
245 for (i
= 0; i
< selected_processes
->len
; i
++) {
246 stored_process
= g_ptr_array_index(selected_processes
, i
);
249 if (stored_process
->tid
== selected_process
->tid
)
250 g_ptr_array_remove(selected_processes
,
252 print_log("Process removed");
255 g_ptr_array_add(selected_processes
, selected_process
);
256 print_log("Process added");
260 void print_key(WINDOW
*win
, char *key
, char *desc
, int toggle
)
267 wattron(win
, COLOR_PAIR(pair
));
268 wprintw(footer
, "%s", key
);
269 wattroff(win
, COLOR_PAIR(pair
));
270 wprintw(footer
, ":%s", desc
);
275 sem_wait(&update_display_sem
);
278 print_key(footer
, "F2", "CPUtop ", current_view
== cpu
);
279 print_key(footer
, "F3", "PerfTop ", current_view
== perf
);
280 print_key(footer
, "F4", "IOTop ", current_view
== iostream
);
281 print_key(footer
, "Enter", "Details ", current_view
== process_details
);
282 print_key(footer
, "Space", "Highlight ", 0);
283 print_key(footer
, "q", "Quit ", 0);
284 print_key(footer
, "r", "Pref ", 0);
285 print_key(footer
, "t", "Threads ", toggle_threads
);
286 print_key(footer
, "p", "Pause ", toggle_pause
);
289 sem_post(&update_display_sem
);
296 set_window_title(header
, "Statistics for interval [gathering data...[");
297 wattron(header
, A_BOLD
);
298 mvwprintw(header
, 1, 4, "CPUs");
299 mvwprintw(header
, 2, 4, "Threads");
300 mvwprintw(header
, 3, 4, "FDs");
301 wattroff(header
, A_BOLD
);
305 static void scale_unit(uint64_t bytes
, char *ret
)
307 if (bytes
>= 1000000000)
308 sprintf(ret
, "%" PRIu64
"G", bytes
/1000000000);
309 if (bytes
>= 1000000)
310 sprintf(ret
, "%" PRIu64
"M", bytes
/1000000);
311 else if (bytes
>= 1000)
312 sprintf(ret
, "%" PRIu64
"K", bytes
/1000);
314 sprintf(ret
, "%" PRIu64
, bytes
);
320 struct processtop
*tmp
;
323 for (i
= 0; i
< data
->process_table
->len
; i
++) {
324 tmp
= g_ptr_array_index(data
->process_table
, i
);
325 total
+= tmp
->fileread
;
326 total
+= tmp
->filewrite
;
334 struct tm start
, end
;
335 uint64_t ts_nsec_start
, ts_nsec_end
;
338 ts_nsec_start
= data
->start
% NSEC_PER_SEC
;
339 start
= format_timestamp(data
->start
);
341 ts_nsec_end
= data
->end
% NSEC_PER_SEC
;
342 end
= format_timestamp(data
->end
);
346 set_window_title(header
, "Statistics for interval ");
347 wattron(header
, A_BOLD
);
349 wprintw(header
, "[%02d:%02d:%02d.%09" PRIu64
", %02d:%02d:%02d.%09" PRIu64
"[",
350 start
.tm_hour
, start
.tm_min
, start
.tm_sec
, ts_nsec_start
,
351 end
.tm_hour
, end
.tm_min
, end
.tm_sec
, ts_nsec_end
);
352 mvwprintw(header
, 1, 4, "CPUs");
353 wattroff(header
, A_BOLD
);
354 wprintw(header
, "\t%d\t(max/cpu : %0.2f%)", data
->cpu_table
->len
,
355 100.0/data
->cpu_table
->len
);
356 print_headers(2, "Threads", data
->nbthreads
, data
->nbnewthreads
,
357 -1*(data
->nbdeadthreads
));
358 print_headers(3, "FDs", data
->nbfiles
, data
->nbnewfiles
,
359 -1*(data
->nbclosedfiles
));
360 scale_unit(total_io(), io
);
361 mvwprintw(header
, 3, 43, "%sB/sec", io
);
365 gint
sort_by_cpu_desc(gconstpointer p1
, gconstpointer p2
)
367 struct processtop
*n1
= *(struct processtop
**)p1
;
368 struct processtop
*n2
= *(struct processtop
**)p2
;
369 unsigned long totaln1
= n1
->totalcpunsec
;
370 unsigned long totaln2
= n2
->totalcpunsec
;
372 if (totaln1
< totaln2
)
374 if (totaln1
== totaln2
)
379 gint
sort_by_tid_desc(gconstpointer p1
, gconstpointer p2
)
381 struct processtop
*n1
= *(struct processtop
**)p1
;
382 struct processtop
*n2
= *(struct processtop
**)p2
;
383 unsigned long totaln1
= n1
->tid
;
384 unsigned long totaln2
= n2
->tid
;
386 if (totaln1
< totaln2
)
388 if (totaln1
== totaln2
)
393 gint
sort_by_pid_desc(gconstpointer p1
, gconstpointer p2
)
395 struct processtop
*n1
= *(struct processtop
**)p1
;
396 struct processtop
*n2
= *(struct processtop
**)p2
;
397 unsigned long totaln1
= n1
->pid
;
398 unsigned long totaln2
= n2
->pid
;
400 if (totaln1
< totaln2
)
402 if (totaln1
== totaln2
)
407 gint
sort_by_process_read_desc(gconstpointer p1
, gconstpointer p2
)
409 struct processtop
*n1
= *(struct processtop
**)p1
;
410 struct processtop
*n2
= *(struct processtop
**)p2
;
411 unsigned long totaln1
= n1
->fileread
;
412 unsigned long totaln2
= n2
->fileread
;
414 if (totaln1
< totaln2
)
416 if (totaln1
== totaln2
)
421 gint
sort_by_process_write_desc(gconstpointer p1
, gconstpointer p2
)
423 struct processtop
*n1
= *(struct processtop
**)p1
;
424 struct processtop
*n2
= *(struct processtop
**)p2
;
425 unsigned long totaln1
= n1
->filewrite
;
426 unsigned long totaln2
= n2
->filewrite
;
428 if (totaln1
< totaln2
)
430 if (totaln1
== totaln2
)
435 gint
sort_by_process_total_desc(gconstpointer p1
, gconstpointer p2
)
437 struct processtop
*n1
= *(struct processtop
**)p1
;
438 struct processtop
*n2
= *(struct processtop
**)p2
;
439 unsigned long totaln1
= n1
->totalfilewrite
+ n1
->totalfileread
;
440 unsigned long totaln2
= n2
->totalfilewrite
+ n2
->totalfileread
;
442 if (totaln1
< totaln2
)
444 if (totaln1
== totaln2
)
449 gint
sort_by_file_read_desc(gconstpointer p1
, gconstpointer p2
)
451 struct files
*n1
= *(struct files
**)p1
;
452 struct files
*n2
= *(struct files
**)p2
;
453 unsigned long totaln1
;
454 unsigned long totaln2
;
459 if (totaln1
< totaln2
)
461 if (totaln1
== totaln2
)
466 gint
sort_by_file_write_desc(gconstpointer p1
, gconstpointer p2
)
468 struct files
*n1
= *(struct files
**)p1
;
469 struct files
*n2
= *(struct files
**)p2
;
470 unsigned long totaln1
;
471 unsigned long totaln2
;
476 if (totaln1
< totaln2
)
478 if (totaln1
== totaln2
)
483 gint
sort_by_file_fd_desc(gconstpointer p1
, gconstpointer p2
)
485 struct files
*n1
= *(struct files
**)p1
;
486 struct files
*n2
= *(struct files
**)p2
;
487 unsigned long totaln1
;
488 unsigned long totaln2
;
493 if (totaln1
< totaln2
)
495 if (totaln1
== totaln2
)
500 gint
sort_by_cpu_group_by_threads_desc(gconstpointer p1
, gconstpointer p2
)
502 struct processtop
*n1
= *(struct processtop
**)p1
;
503 struct processtop
*n2
= *(struct processtop
**)p2
;
504 unsigned long totaln1
= n1
->threadstotalcpunsec
;
505 unsigned long totaln2
= n2
->threadstotalcpunsec
;
507 if (totaln1
< totaln2
)
509 if (totaln1
== totaln2
)
514 void update_cputop_display()
517 int header_offset
= 2;
518 struct processtop
*tmp
;
519 unsigned long elapsed
;
521 int nblinedisplayed
= 0;
522 int current_line
= 0;
525 elapsed
= data
->end
- data
->start
;
526 maxcputime
= elapsed
* data
->cpu_table
->len
/ 100.0;
528 if (cputopview
[0].sort
== 1)
529 g_ptr_array_sort(data
->process_table
, sort_by_cpu_desc
);
530 else if (cputopview
[1].sort
== 1)
531 g_ptr_array_sort(data
->process_table
, sort_by_pid_desc
);
532 else if (cputopview
[2].sort
== 1)
533 g_ptr_array_sort(data
->process_table
, sort_by_tid_desc
);
534 else if (cputopview
[3].sort
== 1)
535 g_ptr_array_sort(data
->process_table
, sort_by_cpu_desc
);
537 g_ptr_array_sort(data
->process_table
, sort_by_cpu_desc
);
539 set_window_title(center
, "CPU Top");
540 wattron(center
, A_BOLD
);
542 for (i
= 0; i
< 4; i
++) {
543 if (cputopview
[i
].sort
) {
544 wattron(center
, A_UNDERLINE
);
545 pref_current_sort
= i
;
547 mvwprintw(center
, 1, column
, cputopview
[i
].title
);
548 wattroff(center
, A_UNDERLINE
);
551 wattroff(center
, A_BOLD
);
553 max_center_lines
= LINES
- 5 - 7 - 1 - header_offset
;
555 /* iterate the process (thread) list */
556 for (i
= list_offset
; i
< data
->process_table
->len
&&
557 nblinedisplayed
< max_center_lines
; i
++) {
558 tmp
= g_ptr_array_index(data
->process_table
, i
);
559 if (tmp
->pid
!= tmp
->tid
)
560 if (toggle_threads
== -1)
563 if (process_selected(tmp
)) {
564 wattron(center
, COLOR_PAIR(6));
565 mvwhline(center
, current_line
+ header_offset
, 1, ' ', COLS
-3);
567 if (current_line
== selected_line
) {
568 selected_process
= tmp
;
569 wattron(center
, COLOR_PAIR(5));
570 mvwhline(center
, current_line
+ header_offset
, 1, ' ', COLS
-3);
573 mvwprintw(center
, current_line
+ header_offset
, 1, "%1.2f",
574 tmp
->totalcpunsec
/ maxcputime
);
576 mvwprintw(center
, current_line
+ header_offset
, 11, "%d", tmp
->pid
);
578 mvwprintw(center
, current_line
+ header_offset
, 21, "%d", tmp
->tid
);
580 mvwprintw(center
, current_line
+ header_offset
, 31, "%s", tmp
->comm
);
581 wattroff(center
, COLOR_PAIR(6));
582 wattroff(center
, COLOR_PAIR(5));
588 gint
sort_perf(gconstpointer p1
, gconstpointer p2
, gpointer key
)
590 struct processtop
*n1
= *(struct processtop
**) p1
;
591 struct processtop
*n2
= *(struct processtop
**) p2
;
593 struct perfcounter
*tmp1
, *tmp2
;
594 unsigned long totaln2
= 0;
595 unsigned long totaln1
= 0;
600 tmp1
= g_hash_table_lookup(n1
->perf
, key
);
604 totaln1
= tmp1
->count
;
606 tmp2
= g_hash_table_lookup(n2
->perf
, key
);
610 totaln2
= tmp2
->count
;
612 if (totaln1
< totaln2
)
614 if (totaln1
== totaln2
) {
617 if (totaln1
< totaln2
)
624 void print_key_title(char *key
, int line
)
626 wattron(center
, A_BOLD
);
627 mvwprintw(center
, line
, 1, "%s", key
);
628 mvwprintw(center
, line
, 30, " ");
629 wattroff(center
, A_BOLD
);
632 void update_process_details()
634 unsigned long elapsed
;
636 struct processtop
*tmp
;
637 struct files
*file_tmp
;
640 char filename_buf
[COLS
];
643 GPtrArray
*newfilearray
= g_ptr_array_new();
645 struct perfcounter
*perfn1
, *perfn2
;
648 set_window_title(center
, "Process details");
651 tmp
= find_process_tid(data
,
652 selected_process
->tid
,
653 selected_process
->comm
);
654 elapsed
= data
->end
- data
->start
;
655 maxcputime
= elapsed
* data
->cpu_table
->len
/ 100.0;
657 print_key_title("Name", line
++);
658 wprintw(center
, "%s", selected_process
->comm
);
659 print_key_title("TID", line
++);
660 wprintw(center
, "%d", selected_process
->tid
);
662 print_key_title("Does not exit at this time", 3);
666 print_key_title("PID", line
++);
667 wprintw(center
, "%d", tmp
->pid
);
668 print_key_title("PPID", line
++);
669 wprintw(center
, "%d", tmp
->ppid
);
670 print_key_title("CPU", line
++);
671 wprintw(center
, "%1.2f %%", tmp
->totalcpunsec
/maxcputime
);
673 print_key_title("READ B/s", line
++);
674 scale_unit(tmp
->fileread
, unit
);
675 wprintw(center
, "%s", unit
);
677 print_key_title("WRITE B/s", line
++);
678 scale_unit(tmp
->filewrite
, unit
);
679 wprintw(center
, "%s", unit
);
681 g_hash_table_iter_init(&iter
, global_perf_liszt
);
682 while (g_hash_table_iter_next (&iter
, &key
, (gpointer
) &perfn1
)) {
683 print_key_title((char *) key
, line
++);
684 perfn2
= g_hash_table_lookup(tmp
->perf
, (char *) key
);
685 wprintw(center
, "%d", perfn2
? perfn2
->count
: 0);
689 wattron(center
, A_BOLD
);
691 for (i
= 0; i
< 3; i
++) {
692 if (fileview
[i
].sort
) {
693 pref_current_sort
= i
;
694 wattron(center
, A_UNDERLINE
);
696 mvwprintw(center
, line
, column
, fileview
[i
].title
);
697 wattroff(center
, A_UNDERLINE
);
700 mvwprintw(center
, line
++, column
, "FILENAME");
701 wattroff(center
, A_BOLD
);
704 * since the process_files_table array could contain NULL file structures,
705 * and that the positions inside the array is important (it is the FD), we
706 * need to create a temporary array that we can sort.
708 for (i
= 0; i
< tmp
->process_files_table
->len
; i
++) {
709 file_tmp
= g_ptr_array_index(tmp
->process_files_table
, i
);
711 g_ptr_array_add(newfilearray
, file_tmp
);
714 if (fileview
[0].sort
== 1)
715 g_ptr_array_sort(newfilearray
, sort_by_file_fd_desc
);
716 else if (fileview
[1].sort
== 1)
717 g_ptr_array_sort(newfilearray
, sort_by_file_read_desc
);
718 else if (fileview
[2].sort
== 1)
719 g_ptr_array_sort(newfilearray
, sort_by_file_write_desc
);
721 g_ptr_array_sort(newfilearray
, sort_by_file_read_desc
);
723 for (i
= selected_line
; i
< newfilearray
->len
&&
724 i
< (selected_line
+ max_center_lines
- line
+ 2); i
++) {
725 file_tmp
= g_ptr_array_index(newfilearray
, i
);
728 mvwprintw(center
, line
+ j
, 1, "%d", file_tmp
->fd
);
729 scale_unit(file_tmp
->read
, unit
);
730 mvwprintw(center
, line
+ j
, 11, "%s", unit
);
731 scale_unit(file_tmp
->write
, unit
);
732 mvwprintw(center
, line
+ j
, 21, "%s", unit
);
733 snprintf(filename_buf
, COLS
- 25, "%s", file_tmp
->name
);
734 mvwprintw(center
, line
+ j
, 31, "%s", filename_buf
);
737 g_ptr_array_free(newfilearray
, TRUE
);
743 int nblinedisplayed
= 0;
744 int current_line
= 0;
745 struct processtop
*tmp
;
746 int header_offset
= 2;
748 struct perfcounter
*perfn1
, *perfn2
;
749 char *perf_key
= NULL
;
754 set_window_title(center
, "Perf Top");
755 wattron(center
, A_BOLD
);
756 mvwprintw(center
, 1, 1, "PID");
757 mvwprintw(center
, 1, 11, "TID");
758 mvwprintw(center
, 1, 22, "NAME");
761 g_hash_table_iter_init(&iter
, global_perf_liszt
);
762 while (g_hash_table_iter_next (&iter
, &key
, (gpointer
) &perfn1
)) {
763 if (perfn1
->visible
) {
765 /* pref_current_sort = i; */
766 wattron(center
, A_UNDERLINE
);
768 /* + 5 to strip the "perf_" prefix */
769 mvwprintw(center
, 1, perf_row
, "%s",
771 wattroff(center
, A_UNDERLINE
);
775 perf_key
= (char *) key
;
778 wattroff(center
, A_BOLD
);
780 g_ptr_array_sort_with_data(data
->process_table
, sort_perf
, perf_key
);
782 for (i
= 0; i
< data
->process_table
->len
&&
783 nblinedisplayed
< max_center_lines
; i
++) {
784 tmp
= g_ptr_array_index(data
->process_table
, i
);
785 if (tmp
->pid
!= tmp
->tid
)
786 if (toggle_threads
== -1)
789 if (process_selected(tmp
)) {
790 wattron(center
, COLOR_PAIR(6));
791 mvwhline(center
, current_line
+ header_offset
, 1, ' ', COLS
-3);
793 if (current_line
== selected_line
) {
794 selected_process
= tmp
;
795 wattron(center
, COLOR_PAIR(5));
796 mvwhline(center
, current_line
+ header_offset
, 1, ' ', COLS
-3);
799 mvwprintw(center
, current_line
+ header_offset
, 1, "%d", tmp
->pid
);
800 mvwprintw(center
, current_line
+ header_offset
, 11, "%d", tmp
->tid
);
801 mvwprintw(center
, current_line
+ header_offset
, 22, "%s", tmp
->comm
);
803 g_hash_table_iter_init(&iter
, global_perf_liszt
);
806 while (g_hash_table_iter_next (&iter
, &key
, (gpointer
) &perfn1
)) {
807 if (perfn1
->visible
) {
808 perfn2
= g_hash_table_lookup(tmp
->perf
, (char *) key
);
810 value
= perfn2
->count
;
813 mvwprintw(center
, current_line
+ header_offset
,
814 perf_row
, "%d", value
);
819 wattroff(center
, COLOR_PAIR(6));
820 wattroff(center
, COLOR_PAIR(5));
826 void update_iostream()
829 int header_offset
= 2;
830 struct processtop
*tmp
;
831 int nblinedisplayed
= 0;
832 int current_line
= 0;
837 set_window_title(center
, "IO Top");
838 wattron(center
, A_BOLD
);
839 mvwprintw(center
, 1, 1, "PID");
840 mvwprintw(center
, 1, 11, "TID");
841 mvwprintw(center
, 1, 22, "NAME");
843 for (i
= 0; i
< 3; i
++) {
844 if (iostreamtopview
[i
].sort
) {
845 pref_current_sort
= i
;
846 wattron(center
, A_UNDERLINE
);
848 mvwprintw(center
, 1, column
, iostreamtopview
[i
].title
);
849 wattroff(center
, A_UNDERLINE
);
852 wattroff(center
, A_BOLD
);
853 wattroff(center
, A_UNDERLINE
);
855 if (iostreamtopview
[0].sort
== 1)
856 g_ptr_array_sort(data
->process_table
, sort_by_process_read_desc
);
857 else if (iostreamtopview
[1].sort
== 1)
858 g_ptr_array_sort(data
->process_table
, sort_by_process_write_desc
);
859 else if (iostreamtopview
[2].sort
== 1)
860 g_ptr_array_sort(data
->process_table
, sort_by_process_total_desc
);
862 g_ptr_array_sort(data
->process_table
, sort_by_process_total_desc
);
864 for (i
= list_offset
; i
< data
->process_table
->len
&&
865 nblinedisplayed
< max_center_lines
; i
++) {
866 tmp
= g_ptr_array_index(data
->process_table
, i
);
867 if (tmp
->pid
!= tmp
->tid
)
868 if (toggle_threads
== -1)
871 if (process_selected(tmp
)) {
872 wattron(center
, COLOR_PAIR(6));
873 mvwhline(center
, current_line
+ header_offset
, 1, ' ', COLS
-3);
875 if (current_line
== selected_line
) {
876 selected_process
= tmp
;
877 wattron(center
, COLOR_PAIR(5));
878 mvwhline(center
, current_line
+ header_offset
, 1, ' ', COLS
-3);
881 mvwprintw(center
, current_line
+ header_offset
, 1, "%d", tmp
->pid
);
883 mvwprintw(center
, current_line
+ header_offset
, 11, "%d", tmp
->tid
);
885 mvwprintw(center
, current_line
+ header_offset
, 22, "%s", tmp
->comm
);
887 /* READ (bytes/sec) */
888 scale_unit(tmp
->fileread
, unit
);
889 mvwprintw(center
, current_line
+ header_offset
, 40, "%s", unit
);
891 /* WRITE (bytes/sec) */
892 scale_unit(tmp
->filewrite
, unit
);
893 mvwprintw(center
, current_line
+ header_offset
, 52, "%s", unit
);
896 total
= tmp
->totalfileread
+ tmp
->totalfilewrite
;
898 scale_unit(total
, unit
);
899 mvwprintw(center
, current_line
+ header_offset
, 64, "%s", unit
);
901 wattroff(center
, COLOR_PAIR(6));
902 wattroff(center
, COLOR_PAIR(5));
908 void update_current_view()
910 sem_wait(&update_display_sem
);
917 switch (current_view
) {
919 update_cputop_display();
924 case process_details
:
925 update_process_details();
931 update_cputop_display();
938 sem_post(&update_display_sem
);
941 void update_process_detail_sort(int *line_selected
)
948 if (*line_selected
> (size
- 1))
949 *line_selected
= size
- 1;
950 else if (*line_selected
< 0)
953 if (fileview
[*line_selected
].sort
== 1)
954 fileview
[*line_selected
].reverse
= 1;
955 for (i
= 0; i
< size
; i
++)
956 fileview
[i
].sort
= 0;
957 fileview
[*line_selected
].sort
= 1;
960 void update_process_detail_pref(int *line_selected
, int toggle_view
, int toggle_sort
)
967 if (pref_panel_window
) {
968 del_panel(pref_panel
);
969 delwin(pref_panel_window
);
973 pref_panel_window
= create_window(size
+ 2, 30, 10, 10);
974 pref_panel
= new_panel(pref_panel_window
);
976 werase(pref_panel_window
);
977 box(pref_panel_window
, 0 , 0);
978 set_window_title(pref_panel_window
, "Process Detail Preferences ");
979 wattron(pref_panel_window
, A_BOLD
);
980 mvwprintw(pref_panel_window
, size
+ 1, 1,
981 " 's' : sort, space : toggle");
982 wattroff(pref_panel_window
, A_BOLD
);
984 if (*line_selected
> (size
- 1))
985 *line_selected
= size
- 1;
986 else if (*line_selected
< 0)
988 if (toggle_sort
== 1) {
989 update_process_detail_sort(line_selected
);
990 update_current_view();
993 for (i
= 0; i
< size
; i
++) {
994 if (i
== *line_selected
) {
995 wattron(pref_panel_window
, COLOR_PAIR(5));
996 mvwhline(pref_panel_window
, i
+ 1, 1, ' ', 30 - 2);
998 if (fileview
[i
].sort
== 1)
999 wattron(pref_panel_window
, A_BOLD
);
1000 mvwprintw(pref_panel_window
, i
+ 1, 1, "[-] %s",
1002 wattroff(pref_panel_window
, A_BOLD
);
1003 wattroff(pref_panel_window
, COLOR_PAIR(5));
1010 void update_iostream_sort(int *line_selected
)
1016 if (*line_selected
> (size
- 1))
1017 *line_selected
= size
- 1;
1018 else if (*line_selected
< 0)
1020 if (iostreamtopview
[*line_selected
].sort
== 1)
1021 iostreamtopview
[*line_selected
].reverse
= 1;
1022 for (i
= 0; i
< size
; i
++)
1023 iostreamtopview
[i
].sort
= 0;
1024 iostreamtopview
[*line_selected
].sort
= 1;
1028 void update_iostream_pref(int *line_selected
, int toggle_view
, int toggle_sort
)
1035 if (pref_panel_window
) {
1036 del_panel(pref_panel
);
1037 delwin(pref_panel_window
);
1041 pref_panel_window
= create_window(size
+ 2, 30, 10, 10);
1042 pref_panel
= new_panel(pref_panel_window
);
1044 werase(pref_panel_window
);
1045 box(pref_panel_window
, 0 , 0);
1046 set_window_title(pref_panel_window
, "IOTop Preferences ");
1047 wattron(pref_panel_window
, A_BOLD
);
1048 mvwprintw(pref_panel_window
, size
+ 1, 1,
1049 " 's' : sort, space : toggle");
1050 wattroff(pref_panel_window
, A_BOLD
);
1052 if (*line_selected
> (size
- 1))
1053 *line_selected
= size
- 1;
1054 else if (*line_selected
< 0)
1056 if (toggle_sort
== 1) {
1057 update_iostream_sort(line_selected
);
1058 update_current_view();
1061 for (i
= 0; i
< size
; i
++) {
1062 if (i
== *line_selected
) {
1063 wattron(pref_panel_window
, COLOR_PAIR(5));
1064 mvwhline(pref_panel_window
, i
+ 1, 1, ' ', 30 - 2);
1066 if (iostreamtopview
[i
].sort
== 1)
1067 wattron(pref_panel_window
, A_BOLD
);
1068 mvwprintw(pref_panel_window
, i
+ 1, 1, "[-] %s",
1069 iostreamtopview
[i
].title
);
1070 wattroff(pref_panel_window
, A_BOLD
);
1071 wattroff(pref_panel_window
, COLOR_PAIR(5));
1078 void update_cpu_sort(int *line_selected
)
1083 if (*line_selected
> (size
- 1))
1084 *line_selected
= size
- 1;
1085 else if (*line_selected
< 0)
1088 /* special case, we don't support sorting by procname for now */
1089 if (*line_selected
!= 3) {
1090 if (cputopview
[*line_selected
].sort
== 1)
1091 cputopview
[*line_selected
].reverse
= 1;
1092 for (i
= 0; i
< size
; i
++)
1093 cputopview
[i
].sort
= 0;
1094 cputopview
[*line_selected
].sort
= 1;
1098 void update_cpu_pref(int *line_selected
, int toggle_view
, int toggle_sort
)
1105 if (pref_panel_window
) {
1106 del_panel(pref_panel
);
1107 delwin(pref_panel_window
);
1111 pref_panel_window
= create_window(size
+ 2, 30, 10, 10);
1112 pref_panel
= new_panel(pref_panel_window
);
1114 werase(pref_panel_window
);
1115 box(pref_panel_window
, 0 , 0);
1116 set_window_title(pref_panel_window
, "CPUTop Preferences ");
1117 wattron(pref_panel_window
, A_BOLD
);
1118 mvwprintw(pref_panel_window
, size
+ 1, 1,
1119 " 's' : sort, space : toggle");
1120 wattroff(pref_panel_window
, A_BOLD
);
1122 if (*line_selected
> (size
- 1))
1123 *line_selected
= size
- 1;
1124 else if (*line_selected
< 0)
1126 if (toggle_sort
== 1) {
1127 update_cpu_sort(line_selected
);
1128 update_current_view();
1131 for (i
= 0; i
< size
; i
++) {
1132 if (i
== *line_selected
) {
1133 wattron(pref_panel_window
, COLOR_PAIR(5));
1134 mvwhline(pref_panel_window
, i
+ 1, 1, ' ', 30 - 2);
1136 if (cputopview
[i
].sort
== 1)
1137 wattron(pref_panel_window
, A_BOLD
);
1138 mvwprintw(pref_panel_window
, i
+ 1, 1, "[-] %s",
1139 cputopview
[i
].title
);
1140 wattroff(pref_panel_window
, A_BOLD
);
1141 wattroff(pref_panel_window
, COLOR_PAIR(5));
1148 void update_perf_sort(int *line_selected
)
1151 struct perfcounter
*perf
;
1155 size
= g_hash_table_size(global_perf_liszt
);
1156 if (*line_selected
> (size
- 1))
1157 *line_selected
= size
- 1;
1158 else if (*line_selected
< 0)
1162 perflist
= g_list_first(g_hash_table_get_keys(global_perf_liszt
));
1164 perf
= g_hash_table_lookup(global_perf_liszt
, perflist
->data
);
1165 if (i
!= *line_selected
)
1170 perflist
= g_list_next(perflist
);
1174 void update_perf_pref(int *line_selected
, int toggle_view
, int toggle_sort
)
1177 struct perfcounter
*perf
;
1183 if (pref_panel_window
) {
1184 del_panel(pref_panel
);
1185 delwin(pref_panel_window
);
1187 size
= g_hash_table_size(global_perf_liszt
);
1189 pref_panel_window
= create_window(size
+ 2, 30, 10, 10);
1190 pref_panel
= new_panel(pref_panel_window
);
1192 werase(pref_panel_window
);
1193 box(pref_panel_window
, 0 , 0);
1194 set_window_title(pref_panel_window
, "Perf Preferences ");
1195 wattron(pref_panel_window
, A_BOLD
);
1196 mvwprintw(pref_panel_window
, g_hash_table_size(global_perf_liszt
) + 1, 1,
1197 " 's' : sort, space : toggle");
1198 wattroff(pref_panel_window
, A_BOLD
);
1200 if (*line_selected
> (size
- 1))
1201 *line_selected
= size
- 1;
1202 else if (*line_selected
< 0)
1205 if (toggle_sort
== 1) {
1206 update_perf_sort(line_selected
);
1207 update_current_view();
1211 perflist
= g_list_first(g_hash_table_get_keys(global_perf_liszt
));
1213 perf
= g_hash_table_lookup(global_perf_liszt
, perflist
->data
);
1214 if (i
== *line_selected
&& toggle_view
== 1) {
1215 perf
->visible
= perf
->visible
== 1 ? 0:1;
1216 update_current_view();
1218 if (i
== *line_selected
) {
1219 wattron(pref_panel_window
, COLOR_PAIR(5));
1220 mvwhline(pref_panel_window
, i
+ 1, 1, ' ', 30 - 2);
1222 if (perf
->sort
== 1)
1223 wattron(pref_panel_window
, A_BOLD
);
1224 mvwprintw(pref_panel_window
, i
+ 1, 1, "[%c] %s",
1225 perf
->visible
== 1 ? 'x' : ' ',
1226 (char *) perflist
->data
+ 5);
1227 wattroff(pref_panel_window
, A_BOLD
);
1228 wattroff(pref_panel_window
, COLOR_PAIR(5));
1230 perflist
= g_list_next(perflist
);
1236 int update_preference_panel(int *line_selected
, int toggle_view
, int toggle_sort
)
1240 switch(current_view
) {
1242 update_perf_pref(line_selected
, toggle_view
, toggle_sort
);
1245 update_cpu_pref(line_selected
, toggle_view
, toggle_sort
);
1248 update_iostream_pref(line_selected
, toggle_view
, toggle_sort
);
1250 case process_details
:
1251 update_process_detail_pref(line_selected
, toggle_view
, toggle_sort
);
1261 int update_sort(int *line_selected
)
1265 switch(current_view
) {
1267 update_perf_sort(line_selected
);
1270 update_cpu_sort(line_selected
);
1273 update_iostream_sort(line_selected
);
1275 case process_details
:
1276 update_process_detail_sort(line_selected
);
1287 void toggle_pref_panel(void)
1291 if (pref_panel_visible
) {
1292 hide_panel(pref_panel
);
1293 pref_panel_visible
= 0;
1295 ret
= update_preference_panel(&pref_line_selected
, 0, 0);
1298 show_panel(pref_panel
);
1299 pref_panel_visible
= 1;
1305 void display(unsigned int index
)
1307 last_display_index
= index
;
1308 currently_displayed_index
= index
;
1309 data
= g_ptr_array_index(copies
, index
);
1312 max_elements
= data
->process_table
->len
;
1313 update_current_view();
1319 void pause_display()
1323 sem_wait(&pause_sem
);
1326 void resume_display()
1329 print_log("Resume");
1330 sem_post(&pause_sem
);
1333 void *handle_keyboard(void *p
)
1336 while((ch
= getch())) {
1338 /* Move the cursor and scroll */
1341 if (pref_panel_visible
) {
1342 pref_line_selected
++;
1343 update_preference_panel(&pref_line_selected
, 0, 0);
1345 if (selected_line
< (max_center_lines
- 1) &&
1346 selected_line
< max_elements
- 1) {
1349 } else if (selected_in_list
< (max_elements
- 1)
1350 && (list_offset
< (max_elements
- max_center_lines
))) {
1354 update_current_view();
1361 if (pref_panel_visible
) {
1362 if (pref_line_selected
> 0)
1363 pref_line_selected
--;
1364 update_preference_panel(&pref_line_selected
, 0, 0);
1366 if (selected_line
> 0) {
1369 } else if (selected_in_list
> 0 && list_offset
> 0) {
1373 update_current_view();
1379 /* Navigate the history with arrows */
1381 if (currently_displayed_index
> 0) {
1382 currently_displayed_index
--;
1383 print_log("Going back in time");
1385 print_log("Cannot rewind, last data is already displayed");
1387 data
= g_ptr_array_index(copies
, currently_displayed_index
);
1388 max_elements
= data
->process_table
->len
;
1390 /* we force to pause the display when moving in time */
1391 if (toggle_pause
< 0)
1394 update_current_view();
1398 if (currently_displayed_index
< last_display_index
) {
1399 currently_displayed_index
++;
1400 print_log("Going forward in time");
1401 data
= g_ptr_array_index(copies
, currently_displayed_index
);
1402 max_elements
= data
->process_table
->len
;
1403 update_current_view();
1406 print_log("Manually moving forward");
1408 if (toggle_pause
> 0) {
1409 sem_post(&pause_sem
);
1410 update_current_view();
1411 sem_wait(&pause_sem
);
1417 if (pref_panel_visible
) {
1418 update_preference_panel(&pref_line_selected
, 1, 0);
1420 update_selected_processes();
1421 update_current_view();
1425 if (pref_panel_visible
)
1426 update_preference_panel(&pref_line_selected
, 0, 1);
1429 /* perf uses a hashtable, it is ordered backward */
1430 if (current_view
== perf
) {
1431 pref_current_sort
--;
1432 } else if (!pref_panel_visible
) {
1433 pref_current_sort
++;
1435 update_sort(&pref_current_sort
);
1436 update_current_view();
1439 /* perf uses a hashtable, it is ordered backward */
1440 if (current_view
== perf
) {
1441 pref_current_sort
++;
1442 } else if (!pref_panel_visible
) {
1443 pref_current_sort
--;
1445 update_sort(&pref_current_sort
);
1446 update_current_view();
1449 case 13: /* FIXME : KEY_ENTER ?? */
1450 if (pref_panel_visible
)
1452 if (current_view
!= process_details
) {
1453 previous_view
= current_view
;
1454 current_view
= process_details
;
1456 current_view
= previous_view
;
1457 previous_view
= process_details
;
1460 update_current_view();
1464 if (pref_panel_visible
)
1465 toggle_pref_panel();
1468 update_current_view();
1471 if (pref_panel_visible
)
1472 toggle_pref_panel();
1475 update_current_view();
1478 if (pref_panel_visible
)
1479 toggle_pref_panel();
1480 current_view
= perf
;
1482 update_current_view();
1485 if (pref_panel_visible
)
1486 toggle_pref_panel();
1487 current_view
= iostream
;
1489 update_current_view();
1496 toggle_threads
*= -1;
1497 update_current_view();
1500 if (toggle_pause
< 0) {
1507 toggle_pref_panel();
1509 /* ESCAPE, but slow to process, don't know why */
1511 if (pref_panel_visible
)
1512 toggle_pref_panel();
1513 else if (current_view
== process_details
) {
1514 current_view
= previous_view
;
1515 previous_view
= process_details
;
1517 update_current_view();
1521 update_current_view();
1529 void init_view_headers()
1531 cputopview
[0].title
= strdup("CPU(%)");
1532 cputopview
[0].sort
= 1;
1533 cputopview
[1].title
= strdup("PID");
1534 cputopview
[2].title
= strdup("TID");
1535 cputopview
[3].title
= strdup("NAME");
1537 iostreamtopview
[0].title
= strdup("R (B/sec)");
1538 iostreamtopview
[1].title
= strdup("W (B/sec)");
1539 iostreamtopview
[2].title
= strdup("Total (B)");
1540 iostreamtopview
[2].sort
= 1;
1542 fileview
[0].title
= strdup("FD");
1543 fileview
[1].title
= strdup("READ");
1544 fileview
[1].sort
= 1;
1545 fileview
[2].title
= strdup("WRITE");
1550 selected_processes
= g_ptr_array_new();
1551 sem_init(&update_display_sem
, 0, 1);
1552 init_view_headers();
1555 header
= create_window(5, COLS
- 1, 0, 0);
1556 center
= create_window(LINES
- 5 - 7, COLS
- 1, 5, 0);
1557 status
= create_window(MAX_LOG_LINES
+ 2, COLS
- 1, LINES
- 7, 0);
1558 footer
= create_window(1, COLS
- 1, LINES
- 1, 0);
1560 print_log("Starting display");
1562 main_panel
= new_panel(center
);
1569 pthread_create(&keyboard_thread
, NULL
, handle_keyboard
, (void *)NULL
);