lttv/lttv/traceset.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Michel Dagenais
   3  *
   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;
   7  *
   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.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <lttv/traceset.h>
  24 #include <lttv/iattribute.h>
  25 #include <stdio.h>
  26
  27 /* A trace is a sequence of events gathered in the same tracing session. The
  28    events may be stored in several tracefiles in the same directory.
  29    A trace set is defined when several traces are to be analyzed together,
  30    possibly to study the interactions between events in the different traces.
  31 */
  32
  33 struct _LttvTraceset {
  34         char * filename;
  35         GPtrArray *traces;
  36         LttvAttribute *a;
  37 };
  38
  39
  40 struct _LttvTrace {
  41         LttTrace *t;
  42         LttvAttribute *a;
  43         guint ref_count;
  44 };
  45
  46
  47 LttvTraceset *lttv_traceset_new()
  48 {
  49         LttvTraceset *s;
  50
  51         s = g_new(LttvTraceset, 1);
  52         s->filename = NULL;
  53         s->traces = g_ptr_array_new();
  54         s->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
  55         return s;
  56 }
  57
  58 char * lttv_traceset_name(LttvTraceset * s)
  59 {
  60         return s->filename;
  61 }
  62
  63 LttvTrace *lttv_trace_new(LttTrace *t)
  64 {
  65         LttvTrace *new_trace;
  66
  67         new_trace = g_new(LttvTrace, 1);
  68         new_trace->a = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
  69         new_trace->t = t;
  70         new_trace->ref_count = 0;
  71         return new_trace;
  72 }
  73
  74
  75 LttvTraceset *lttv_traceset_copy(LttvTraceset *s_orig)
  76 {
  77         guint i;
  78         LttvTraceset *s;
  79         LttvTrace * trace;
  80
  81         s = g_new(LttvTraceset, 1);
  82         s->filename = NULL;
  83         s->traces = g_ptr_array_new();
  84         for(i=0;i<s_orig->traces->len;i++)
  85         {
  86                 trace = g_ptr_array_index(s_orig->traces, i);
  87                 trace->ref_count++;
  88
  89                 g_ptr_array_add(s->traces, trace);
  90         }
  91         s->a = LTTV_ATTRIBUTE(lttv_iattribute_deep_copy(LTTV_IATTRIBUTE(s_orig->a)));
  92         return s;
  93 }
  94
  95
  96 LttvTraceset *lttv_traceset_load(const gchar *filename)
  97 {
  98         LttvTraceset *s = g_new(LttvTraceset,1);
  99         FILE *tf;
 100
 101         s->filename = g_strdup(filename);
 102         tf = fopen(filename,"r");
 103
 104         g_critical("NOT IMPLEMENTED : load traceset data from a XML file");
 105
 106         fclose(tf);
 107         return s;
 108 }
 109
 110 gint lttv_traceset_save(LttvTraceset *s)
 111 {
 112         FILE *tf;
 113
 114         tf = fopen(s->filename, "w");
 115
 116         g_critical("NOT IMPLEMENTED : save traceset data in a XML file");
 117
 118         fclose(tf);
 119         return 0;
 120 }
 121
 122 void lttv_traceset_destroy(LttvTraceset *s)
 123 {
 124         guint i;
 125
 126         for(i=0;i<s->traces->len;i++) {
 127                 LttvTrace *trace = g_ptr_array_index(s->traces, i);
 128                 lttv_trace_unref(trace);
 129                 if(lttv_trace_get_ref_number(trace) == 0)
 130                         lttv_trace_destroy(trace);
 131         }
 132         g_ptr_array_free(s->traces, TRUE);
 133         g_object_unref(s->a);
 134         g_free(s);
 135 }
 136
 137 void lttv_trace_destroy(LttvTrace *t)
 138 {
 139         g_object_unref(t->a);
 140         g_free(t);
 141 }
 142
 143
 144 void lttv_traceset_add(LttvTraceset *s, LttvTrace *t)
 145 {
 146         t->ref_count++;
 147         g_ptr_array_add(s->traces, t);
 148 }
 149
 150
 151 unsigned lttv_traceset_number(LttvTraceset *s)
 152 {
 153         return s->traces->len;
 154 }
 155
 156
 157 LttvTrace *lttv_traceset_get(LttvTraceset *s, unsigned i)
 158 {
 159         g_assert(s->traces->len > i);
 160         return ((LttvTrace *)s->traces->pdata[i]);
 161 }
 162
 163
 164 void lttv_traceset_remove(LttvTraceset *s, unsigned i)
 165 {
 166         LttvTrace * t;
 167         g_assert(s->traces->len > i);
 168         t = (LttvTrace *)s->traces->pdata[i];
 169         t->ref_count--;
 170         g_ptr_array_remove_index(s->traces, i);
 171 }
 172
 173
 174 /* A set of attributes is attached to each trace set, trace and tracefile
 175          to store user defined data as needed. */
 176
 177 LttvAttribute *lttv_traceset_attribute(LttvTraceset *s)
 178 {
 179         return s->a;
 180 }
 181
 182
 183 LttvAttribute *lttv_trace_attribute(LttvTrace *t)
 184 {
 185         return t->a;
 186 }
 187
 188
 189 LttTrace *lttv_trace(LttvTrace *t)
 190 {
 191         return t->t;
 192 }
 193
 194 guint lttv_trace_get_ref_number(LttvTrace * t)
 195 {
 196         return t->ref_count;
 197 }
 198
 199 guint lttv_trace_ref(LttvTrace * t)
 200 {
 201         t->ref_count++;
 202
 203         return t->ref_count;
 204 }
 205
 206 guint lttv_trace_unref(LttvTrace * t)
 207 {
 208         if(likely(t->ref_count > 0))
 209                 t->ref_count--;
 210
 211         return t->ref_count;
 212 }
 213