unused variable

[lttngtop.git] / src / common.c

diff --git a/src/common.c b/src/common.c
index 2a0f1f47c89a5c3054dd5a6db10d3fa93d667e6c..0d39f303559eeafe729699e5591b54f921e7962b 100644 (file)
--- a/src/common.c
+++ b/src/common.c
@@ -42,14 +42,13 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm,
        /* FIXME : need to integrate with clone/fork/exit to be accurate */
        newproc = find_process_tid(ctx, tid, comm);
        if (!newproc) {
-               newproc = malloc(sizeof(struct processtop));
-               memset(newproc, 0, sizeof(struct processtop));
+               newproc = g_new0(struct processtop, 1);
                newproc->tid = tid;
                newproc->birth = timestamp;
                newproc->process_files_table = g_ptr_array_new();
                newproc->threads = g_ptr_array_new();
-               newproc->perf = g_hash_table_new(g_direct_hash, g_direct_equal);
-               newproc->iostream = malloc(sizeof(struct iostream));
+               newproc->perf = g_hash_table_new(g_str_hash, g_str_equal);
+               newproc->iostream = g_new0(struct iostream, 1);
                newproc->iostream->ret_read = 0;
                newproc->iostream->ret_write = 0;
                newproc->iostream->ret_total = 0;
@@ -116,10 +115,10 @@ struct cputime* add_cpu(int cpu)
 {
        struct cputime *newcpu;
 
-       newcpu = malloc(sizeof(struct cputime));
+       newcpu = g_new0(struct cputime, 1);
        newcpu->id = cpu;
        newcpu->current_task = NULL;
-       newcpu->perf = g_hash_table_new(g_direct_hash, g_direct_equal);
+       newcpu->perf = g_hash_table_new(g_str_hash, g_str_equal);
 
        g_ptr_array_add(lttngtop.cpu_table, newcpu);
 
@@ -173,11 +172,11 @@ void copy_perf_counter(gpointer key, gpointer value, gpointer new_table)
 {
        struct perfcounter *newperf;
        
-       newperf = malloc(sizeof(struct perfcounter));
+       newperf = g_new0(struct perfcounter, 1);
        newperf->count = ((struct perfcounter *) value)->count;
        newperf->visible = ((struct perfcounter *) value)->visible;
        newperf->sort = ((struct perfcounter *) value)->sort;
-       g_hash_table_insert((GHashTable *) new_table, key, newperf);
+       g_hash_table_insert((GHashTable *) new_table, strdup(key), newperf);
 }
 
 void rotate_perfcounter() {
@@ -212,42 +211,40 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end)
        struct cputime *tmpcpu, *newcpu;
        struct files *tmpfile, *newfile;
 
-       dst = malloc(sizeof(struct lttngtop));
-       dst = memset(dst, 0, sizeof(struct lttngtop));
+       dst = g_new0(struct lttngtop, 1);
        dst->start = start;
        dst->end = end;
        dst->process_table = g_ptr_array_new();
        dst->files_table = g_ptr_array_new();
        dst->cpu_table = g_ptr_array_new();
-       dst->perf_list = g_hash_table_new(g_direct_hash, g_direct_equal);
+       dst->perf_list = g_hash_table_new(g_str_hash, g_str_equal);
 
        rotate_cputime(end);
 
        g_hash_table_foreach(lttngtop.perf_list, copy_perf_counter, dst->perf_list);
        for (i = 0; i < lttngtop.process_table->len; i++) {
                tmp = g_ptr_array_index(lttngtop.process_table, i);
-               new = malloc(sizeof(struct processtop));
+               new = g_new0(struct processtop, 1);
 
                memcpy(new, tmp, sizeof(struct processtop));
                new->threads = g_ptr_array_new();
                new->comm = strdup(tmp->comm);
                new->process_files_table = g_ptr_array_new();
-               new->perf = g_hash_table_new(g_direct_hash, g_direct_equal);
+               new->perf = g_hash_table_new(g_str_hash, g_str_equal);
                g_hash_table_foreach(tmp->perf, copy_perf_counter, new->perf);
 
-               new->iostream = malloc(sizeof(struct iostream));
+               new->iostream = g_new0(struct iostream, 1);
                memcpy(new->iostream, tmp->iostream, sizeof(struct iostream));
                /* compute the stream speed */
-               if (end - start != 0)
-               {
-                       time = (end - start)/NSEC_PER_SEC;
-                       new->iostream->ret_read = new->iostream->ret_read/(time);
-                       new->iostream->ret_write = new->iostream->ret_write/(time);
+               if (end - start != 0) {
+                       time = (end - start) / NSEC_PER_SEC;
+                       new->iostream->ret_read = new->iostream->ret_read / time;
+                       new->iostream->ret_write = new->iostream->ret_write / time;
                }
 
                for (j = 0; j < tmp->process_files_table->len; j++) {
                        tmpfile = g_ptr_array_index(tmp->process_files_table, j);
-                       newfile = malloc(sizeof(struct files));
+                       newfile = g_new0(struct files, 1);
 
                        memcpy(newfile, tmpfile, sizeof(struct files));
 
@@ -263,7 +260,7 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end)
                         */
                        if (tmp->death > 0 && tmp->death < end) {
                                g_ptr_array_remove(tmp->process_files_table, tmpfile);
-                               free(tmpfile);
+                               g_free(tmpfile);
                        }
                }
                g_ptr_array_add(dst->process_table, new);
@@ -274,20 +271,22 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end)
                 */
                if (tmp->death > 0 && tmp->death < end) {
                        g_ptr_array_remove(lttngtop.process_table, tmp);
+                       /* FIXME : TRUE does not mean clears the object in it */
                        g_ptr_array_free(tmp->threads, TRUE);
                        free(tmp->comm);
                        g_ptr_array_free(tmp->process_files_table, TRUE);
+                       /* FIXME : clear elements */
                        g_hash_table_destroy(tmp->perf);
-                       free(tmp);
+                       g_free(tmp);
                }
        }
        rotate_perfcounter();
 
        for (i = 0; i < lttngtop.cpu_table->len; i++) {
                tmpcpu = g_ptr_array_index(lttngtop.cpu_table, i);
-               newcpu = malloc(sizeof(struct cputime));
+               newcpu = g_new0(struct cputime, 1);
                memcpy(newcpu, tmpcpu, sizeof(struct cputime));
-               newcpu->perf = g_hash_table_new(g_direct_hash, g_direct_equal);
+               newcpu->perf = g_hash_table_new(g_str_hash, g_str_equal);
                g_hash_table_foreach(tmpcpu->perf, copy_perf_counter, newcpu->perf);
                /*
                 * note : we don't care about the current process pointer in the copy
@@ -295,6 +294,7 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end)
                 */
                g_ptr_array_add(dst->cpu_table, newcpu);
        }
+       /* FIXME : better algo */
        /* create the threads index if required */
        for (i = 0; i < dst->process_table->len; i++) {
                tmp = g_ptr_array_index(dst->process_table, i);