#include "top.h"
static regex_t *exclusion_expression = 0;
-static unsigned int g_time = 0;
+static unsigned long g_time = 0;
static unsigned long previous_total = 0;
static struct process *first_process = 0;
+struct process *get_first_process()
+{
+ return first_process;
+}
+
+void free_all_processes()
+{
+ struct process *next = NULL, *pr = first_process;
+ while (pr) {
+ next = pr->next;
+ if (pr->name) {
+ free(pr->name);
+ }
+ free(pr);
+ pr = next;
+ }
+ first_process = NULL;
+}
+
static struct process *find_process(pid_t pid)
{
struct process *p = first_process;
process->pid = p;
process->time_stamp = 0;
- process->previous_user_time = INT_MAX;
- process->previous_kernel_time = INT_MAX;
+ process->previous_user_time = ULONG_MAX;
+ process->previous_kernel_time = ULONG_MAX;
process->counted = 1;
*q = 0;
}
- if (process->name)
+ if (process->name) {
free(process->name);
+ }
process->name = strdup(deparenthesised_name);
process->rss *= getpagesize();
else
first_process = p->next;
- if (p->name)
+ if (p->name) {
free(p->name);
+ }
free(p);
}
(100.0 * (float) (p->user_time + p->kernel_time) /
total) : 0; */
p->amount =
- (100.0 * (p->user_time + p->kernel_time) / total);
+ 100.0 * ((float)(p->user_time + p->kernel_time) / (float)total);
/* if (p->amount > 100)
p->amount = 0;*/
/* Find the top processes */
/******************************************/
+//static int tot_struct; //for debugging..uncomment this and the 2 printfs in the next two functs
+
+/*
+ * free a sp_process structure
+*/
+void free_sp(struct sorted_process * sp) {
+ free(sp);
+// printf("free: %d structs\n",--tot_struct );
+}
+
+/*
+ * create a new sp_process structure
+*/
+struct sorted_process * malloc_sp(struct process * proc) {
+ struct sorted_process * sp;
+ sp = malloc(sizeof(struct sorted_process));
+ sp->greater = NULL;
+ sp->less = NULL;
+ sp->proc = proc;
+// printf("malloc: %d structs\n", ++tot_struct);
+ return(sp);
+}
/*
* cpu comparison function for insert_sp_element
* insert this process into the list in a sorted fashion,
* or destroy it if it doesn't fit on the list
*/
-int insert_sp_element(
+int insert_sp_element(
struct sorted_process * sp_cur
, struct sorted_process ** p_sp_head
, struct sorted_process ** p_sp_tail
*p_sp_head = sp_cur;
*p_sp_tail = sp_cur;
return(1);
- }
+ }
for(sp_readthru=*p_sp_head, x=0; sp_readthru != NULL && x < max_elements; sp_readthru=sp_readthru->less, x++) {
if (compare_funct(sp_readthru->proc, sp_cur->proc) && !did_insert) {
/* sp_cur is bigger than sp_readthru so insert it before sp_readthru */
sp_readthru->greater=sp_cur;
did_insert = ++x; /* element was inserted, so increase the counter */
}
- }
+ }
if (x < max_elements && sp_readthru == NULL && !did_insert) {
/* sp_cur is the smallest element and list isn't full, so insert at the end */
(*p_sp_tail)->less=sp_cur;
sp_cur->greater=*p_sp_tail;
*p_sp_tail = sp_cur;
did_insert=x;
- } else if (x==max_elements && sp_readthru != NULL) {
+ } else if (x >= max_elements) {
/* we inserted an element and now the list is too big by one. Destroy the smallest element */
- sp_destroy = sp_readthru;
- sp_readthru->greater->less = NULL;
- *p_sp_tail = sp_readthru->greater;
- free(sp_destroy);
+ sp_destroy = *p_sp_tail;
+ *p_sp_tail = sp_destroy->greater;
+ (*p_sp_tail)->less = NULL;
+ free_sp(sp_destroy);
}
if (!did_insert) {
/* sp_cur wasn't added to the sorted list, so destroy it */
- free(sp_cur);
+ free_sp(sp_cur);
}
return did_insert;
-}
-
-/*
- * create a new sp_process structure
-*/
-struct sorted_process * malloc_sp(struct process * proc) {
- struct sorted_process * sp;
- sp = malloc(sizeof(struct sorted_process));
- sp->greater = NULL;
- sp->less = NULL;
- sp->proc = proc;
- return(sp);
-}
+}
/*
* copy the procs in the sorted list to the array, and destroy the list
*/
-void sp_acopy(struct sorted_process *sp_head, struct process ** ar, int max_size) {
-
+void sp_acopy(struct sorted_process *sp_head, struct process ** ar, int max_size)
+{
struct sorted_process * sp_cur, * sp_tmp;
int x;
-
sp_cur = sp_head;
for (x=0; x < max_size && sp_cur != NULL; x++) {
ar[x] = sp_cur->proc;
sp_tmp = sp_cur;
sp_cur= sp_cur->less;
- free(sp_tmp);
+ free_sp(sp_tmp);
}
}
+// stole from common.c
+#define NEED(a) ((need_mask & (1 << a)) && ((info.mask & (1 << a)) == 0))
+
/* ****************************************************************** */
/* Get a sorted list of the top cpu hogs and top mem hogs. */
/* Results are stored in the cpu,mem arrays in decreasing order[0-9]. */
inline void process_find_top(struct process **cpu, struct process **mem)
{
- struct sorted_process *spc_head=NULL, *spc_tail=NULL, *spc_cur=NULL;
- struct sorted_process *spm_head=NULL, *spm_tail=NULL, *spm_cur=NULL;
- struct process *cur_proc=NULL;
- unsigned long total =0;
+ struct sorted_process *spc_head = NULL, *spc_tail = NULL, *spc_cur = NULL;
+ struct sorted_process *spm_head = NULL, *spm_tail = NULL, *spm_cur = NULL;
+ struct process *cur_proc = NULL;
+ unsigned long total = 0;
if (!top_cpu && !top_mem) return;
update_process_table(); /* update the table with process list */
calc_cpu_each(total); /* and then the percentage for each task */
process_cleanup(); /* cleanup list from exited processes */
- update_meminfo();
+
cur_proc = first_process;
while (cur_proc !=NULL) {
- if (top_cpu) {
+ //printf("\n\n cur_proc: %s %f %f\n",cur_proc->name, cur_proc->totalmem, cur_proc->amount );
+ if (top_cpu) {
spc_cur = malloc_sp(cur_proc);
- insert_sp_element(spc_cur, &spc_head, &spc_tail, MAX_SP, &compare_cpu);
- }
+ insert_sp_element(spc_cur, &spc_head, &spc_tail, MAX_SP, &compare_cpu);
+ }
if (top_mem) {
spm_cur = malloc_sp(cur_proc);
- insert_sp_element(spm_cur, &spm_head, &spm_tail, MAX_SP, &compare_mem);
+ insert_sp_element(spm_cur, &spm_head, &spm_tail, MAX_SP, &compare_mem);
}
cur_proc = cur_proc->next;
}
sp_acopy(spc_head, cpu, MAX_SP);
sp_acopy(spm_head, mem, MAX_SP);
-}
+}
+
projects / monky / blobdiff