* LttvTracefileContext{}
* |->event\
* | |->name (String, converted to GQuark)
+ * | |->facility (String, converted to GQuark)
* | |->category (String, not yet implemented)
* | |->time (LttTime)
* | |->tsc (LttCycleCount --> uint64)
* | |->fields
- * | |->"event name"
- * | |->"field name"
- * | |->"sub-field name"
- * | |->...
- * | |->"leaf-field name" (field type)
+ * | |->"facility_name
+ * | |->"event name"
+ * | |->"field name"
+ * | |->"sub-field name"
+ * | |->...
+ * | |->"leaf-field name" (field type)
* |->tracefile
* | |->name (String, converted to GQuark)
* |->trace
* | |->name (String, converted to GQuark)
* |->state
- * |->pid (uint64)
- * |->ppid (uint64)
+ * |->pid (guint)
+ * |->ppid (guint)
* |->creation_time (LttTime)
* |->insertion_time (LttTime)
* |->process_name (String, converted to GQuark)
+ * |->thread_brand (String, converted to GQuark)
* |->execution_mode (LttvExecutionMode)
* |->execution_submode (LttvExecutionSubmode)
* |->process_status (LttvProcessStatus)
- * |->cpu (GQuark)
+ * |->cpu (guint)
* \endverbatim
*/
/*
* \todo
* - refine switch of expression in multiple uses functions
- * - remove the idle expressions in the tree
+ * - remove the idle expressions in the tree
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+//#define TEST
+#ifdef TEST
+#include <time.h>
+#include <sys/time.h>
+#endif
+
+#include <lttv/lttv.h>
#include <lttv/filter.h>
+#include <ltt/trace.h>
+#include <ltt/type.h>
+#include <ltt/facility.h>
+#include <stdlib.h>
+#include <string.h>
/**
* @fn LttvSimpleExpression* lttv_simple_expression_new()
GString* f = NULL;
if(fp->len < 2) return FALSE;
- g_assert(f=g_ptr_array_remove_index(fp,0));
+ g_assert((f=g_ptr_array_remove_index(fp,0)));
/*
* Parse through the specified
* state.creation_time
* state.insertion_time
* state.process_name
+ * state.thread_brand
* state.execution_mode
* state.execution_submode
* state.process_status
else if(!g_strcasecmp(f->str,"process_name") ) {
se->field = LTTV_FILTER_STATE_P_NAME;
}
+ else if(!g_strcasecmp(f->str,"thread_brand") ) {
+ se->field = LTTV_FILTER_STATE_T_BRAND;
+ }
else if(!g_strcasecmp(f->str,"execution_mode") ) {
se->field = LTTV_FILTER_STATE_EX_MODE;
}
* event.category
* event.time
* event.tsc
+ * event.field
*/
g_string_free(f,TRUE);
f=g_ptr_array_remove_index(fp,0);
if(!g_strcasecmp(f->str,"name") ) {
se->field = LTTV_FILTER_EVENT_NAME;
}
+ else if(!g_strcasecmp(f->str,"facility") ) {
+ se->field = LTTV_FILTER_EVENT_FACILITY;
+ }
else if(!g_strcasecmp(f->str,"category") ) {
/*
* FIXME: Category not yet functional in lttv
else if(!g_strcasecmp(f->str,"tsc") ) {
se->field = LTTV_FILTER_EVENT_TSC;
}
- else { /* core.xml specified options */
+ else if(!g_strcasecmp(f->str,"field") ) {
se->field = LTTV_FILTER_EVENT_FIELD;
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+
+ } else {
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+ g_warning("Unknown event filter subtype %s", f->str);
}
} else {
+ g_string_free(f,TRUE);
+ f=g_ptr_array_remove_index(fp,0);
+
g_warning("Unrecognized field in filter string");
}
* @param op current operator
* @return success/failure of operation
*/
-gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) {
+gboolean
+lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) {
switch(se->field) {
/*
case LTTV_FILTER_TRACE_NAME:
case LTTV_FILTER_TRACEFILE_NAME:
case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_STATE_T_BRAND:
case LTTV_FILTER_EVENT_NAME:
- case LTTV_FILTER_STATE_CPU:
+ case LTTV_FILTER_EVENT_FACILITY:
+ case LTTV_FILTER_STATE_EX_MODE:
+ case LTTV_FILTER_STATE_EX_SUBMODE:
+ case LTTV_FILTER_STATE_P_STATUS:
switch(op) {
case LTTV_FIELD_EQ:
se->op = lttv_apply_op_eq_quark;
/*
* integer
*/
- case LTTV_FILTER_STATE_PID:
- case LTTV_FILTER_STATE_PPID:
case LTTV_FILTER_EVENT_TSC:
switch(op) {
case LTTV_FIELD_EQ:
return FALSE;
}
break;
- /*
- * Enums
- * can only be compared with 'equal' or 'not equal' operators
- *
- * unsigned int of 16 bits are used here since enums
- * should not over 2^16-1 values
+ /*
+ * unsigned integers
*/
- case LTTV_FILTER_STATE_EX_MODE:
- case LTTV_FILTER_STATE_EX_SUBMODE:
- case LTTV_FILTER_STATE_P_STATUS:
+ case LTTV_FILTER_STATE_CPU:
+ case LTTV_FILTER_STATE_PID:
+ case LTTV_FILTER_STATE_PPID:
switch(op) {
case LTTV_FIELD_EQ:
- se->op = lttv_apply_op_eq_uint16;
+ se->op = lttv_apply_op_eq_uint;
break;
case LTTV_FIELD_NE:
- se->op = lttv_apply_op_ne_uint16;
+ se->op = lttv_apply_op_ne_uint;
+ break;
+ case LTTV_FIELD_LT:
+ se->op = lttv_apply_op_lt_uint;
+ break;
+ case LTTV_FIELD_LE:
+ se->op = lttv_apply_op_le_uint;
+ break;
+ case LTTV_FIELD_GT:
+ se->op = lttv_apply_op_gt_uint;
+ break;
+ case LTTV_FIELD_GE:
+ se->op = lttv_apply_op_ge_uint;
break;
default:
- g_warning("Error encountered in operator assignment = or != expected");
+ g_warning("Error encountered in operator assignment");
return FALSE;
}
break;
+
+ /*
+ * Enums
+ * Entered as string, converted to enum
+ *
+ * can only be compared with 'equal' or 'not equal' operators
+ *
+ * unsigned int of 16 bits are used here since enums
+ * should not go over 2^16-1 values
+ */
+// case /*NOTHING*/:
+// switch(op) {
+// case LTTV_FIELD_EQ:
+// se->op = lttv_apply_op_eq_uint16;
+// break;
+// case LTTV_FIELD_NE:
+// se->op = lttv_apply_op_ne_uint16;
+// break;
+// default:
+// g_warning("Error encountered in operator assignment = or != expected");
+// return FALSE;
+// }
+// break;
/*
* Ltttime
*/
* @param se pointer to the current LttvSimpleExpression
* @param value string value for simple expression
*/
-gboolean lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) {
+gboolean
+lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) {
unsigned i;
gboolean is_double = FALSE;
LttTime t = ltt_time_zero;
GString* v;
- GQuark quark;
switch(se->field) {
/*
- * string --> g_quark
+ * Strings
+ * entered as strings, converted to Quarks
*/
case LTTV_FILTER_TRACE_NAME:
case LTTV_FILTER_TRACEFILE_NAME:
case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_STATE_T_BRAND:
case LTTV_FILTER_EVENT_NAME:
- case LTTV_FILTER_STATE_CPU:
-// se->value.v_string = value;
- se->value.v_uint32 = g_quark_from_string(value);
+ case LTTV_FILTER_EVENT_FACILITY:
+ case LTTV_FILTER_STATE_EX_MODE:
+ case LTTV_FILTER_STATE_EX_SUBMODE:
+ case LTTV_FILTER_STATE_P_STATUS:
+ // se->value.v_string = value;
+ se->value.v_quark = g_quark_from_string(value);
g_free(value);
break;
/*
- * integer
+ * integer -- supposed to be uint64
*/
- case LTTV_FILTER_STATE_PID:
- case LTTV_FILTER_STATE_PPID:
- case LTTV_FILTER_STATE_EX_MODE:
- case LTTV_FILTER_STATE_EX_SUBMODE:
- case LTTV_FILTER_STATE_P_STATUS:
case LTTV_FILTER_EVENT_TSC:
se->value.v_uint64 = atoi(value);
g_free(value);
break;
+ /*
+ * unsigned integers
+ */
+ case LTTV_FILTER_STATE_PID:
+ case LTTV_FILTER_STATE_PPID:
+ case LTTV_FILTER_STATE_CPU:
+ se->value.v_uint = atoi(value);
+ g_free(value);
+ break;
/*
* LttTime
*/
/* cannot specify number with more than one '.' */
if(is_double) return FALSE;
else is_double = TRUE;
- t.tv_sec = atoi(v);
+ t.tv_sec = atoi(v->str);
g_string_free(v,TRUE);
v = g_string_new("");
} else g_string_append_c(v,value[i]);
}
/* number can be integer or double */
- if(is_double) t.tv_nsec = atoi(v);
- else t.tv_sec = atoi(v);
+ if(is_double) t.tv_nsec = atoi(v->str);
+ else t.tv_sec = atoi(v->str);
g_string_free(v,TRUE);
case LTTV_FILTER_STATE_CT:
case LTTV_FILTER_STATE_IT:
case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_STATE_T_BRAND:
case LTTV_FILTER_STATE_EX_MODE:
case LTTV_FILTER_STATE_EX_SUBMODE:
case LTTV_FILTER_STATE_P_STATUS:
return LTTV_FILTER_STATE;
break;
case LTTV_FILTER_EVENT_NAME:
+ case LTTV_FILTER_EVENT_FACILITY:
case LTTV_FILTER_EVENT_CATEGORY:
case LTTV_FILTER_EVENT_TIME:
case LTTV_FILTER_EVENT_TSC:
}
}
+/**
+ * @fn gboolean lttv_apply_op_eq_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_eq_uint(const gpointer v1, LttvFieldValue v2) {
+
+ guint* r = (guint*) v1;
+ return (*r == v2.v_uint);
+
+}
+
/**
* @fn gboolean lttv_apply_op_eq_uint64(gpointer,LttvFieldValue)
*
*/
gboolean lttv_apply_op_eq_quark(const gpointer v1, LttvFieldValue v2) {
GQuark* r = (GQuark*) v1;
- g_print("v1:%i v2:%i\n",*r,v2.v_uint32);
- return (*r == v2.v_uint32);
+ return (*r == v2.v_quark);
}
/**
return ltt_time_compare(*r, v2.v_ltttime)==0?1:0;
}
+/**
+ * @fn gboolean lttv_apply_op_ne_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'not equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ne_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r != v2.v_uint);
+}
/**
* @fn gboolean lttv_apply_op_ne_uint64(gpointer,LttvFieldValue)
*/
gboolean lttv_apply_op_ne_quark(const gpointer v1, LttvFieldValue v2) {
GQuark* r = (GQuark*) v1;
- return (*r != v2.v_uint32);
+ return (*r != v2.v_quark);
}
return ltt_time_compare(*r, v2.v_ltttime)!=0?1:0;
}
+/**
+ * @fn gboolean lttv_apply_op_lt_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_lt_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r < v2.v_uint);
+}
/**
* @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue)
return ltt_time_compare(*r, v2.v_ltttime)==-1?1:0;
}
+/**
+ * @fn gboolean lttv_apply_op_le_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'lower or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_le_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r <= v2.v_uint);
+}
/**
* @fn gboolean lttv_apply_op_le_uint64(gpointer,LttvFieldValue)
}
+/**
+ * @fn gboolean lttv_apply_op_gt_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater than' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_gt_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r > v2.v_uint);
+}
+
/**
* @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue)
*
return ltt_time_compare(*r, v2.v_ltttime)==1?1:0;
}
+/**
+ * @fn gboolean lttv_apply_op_ge_uint(gpointer,LttvFieldValue)
+ *
+ * Applies the 'greater or equal' operator to the
+ * specified structure and value
+ * @param v1 left member of comparison
+ * @param v2 right member of comparison
+ * @return success/failure of operation
+ */
+gboolean lttv_apply_op_ge_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r >= v2.v_uint);
+}
/**
* @fn gboolean lttv_apply_op_ge_uint64(gpointer,LttvFieldValue)
*/
LttvFilter*
lttv_filter_clone(const LttvFilter* filter) {
-
+
+ if(!filter) return NULL;
+
LttvFilter* newfilter = g_new(LttvFilter,1);
strcpy(newfilter->expression,filter->expression);
int
i,
- p_nesting=0; /* parenthesis nesting value */
-
+ p_nesting=0, /* parenthesis nesting value */
+ not=0;
+
/* trees */
LttvFilterTree
*tree = lttv_filter_tree_new(), /* main tree */
*subtree = NULL, /* buffer for subtrees */
*t1, /* buffer #1 */
- *t2; /* buffer #2 */
+ *t2, /* buffer #2 */
+ *t3; /* buffer #3 */
/*
* the filter
/* temporary values */
GString *a_field_component = g_string_new("");
+ GString *a_string_spaces = g_string_new("");
GPtrArray *a_field_path = g_ptr_array_new();
/* simple expression buffer */
* 2. the subtree is completed, allocate a new subtree
* 3. pop the tree value from the tree stack
*/
+
+#ifdef TEST
+ struct timeval starttime;
+ struct timeval endtime;
+ gettimeofday(&starttime, NULL);
+#endif
for(i=0;i<strlen(filter->expression);i++) {
// debug
- //g_print("%c ",filter->expression[i]);
+// g_print("%c\n ",filter->expression[i]);
switch(filter->expression[i]) {
/*
* logical operators
*/
case '&': /* and */
-
+
+ /* get current tree in tree stack */
t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1);
+
+ /* get current node at absolute right */
while(t1->right != LTTV_TREE_IDLE) {
g_assert(t1->right == LTTV_TREE_NODE);
t1 = t1->r_child.t;
}
t2 = lttv_filter_tree_new();
t2->node = LTTV_LOGICAL_AND;
+ t1->right = LTTV_TREE_NODE;
+ t1->r_child.t = t2;
+ if(not) { /* add not operator to tree */
+ t3 = lttv_filter_tree_new();
+ t3->node = LTTV_LOGICAL_NOT;
+ t2->left = LTTV_TREE_NODE;
+ t2->l_child.t = t3;
+ t2 = t3;
+ not = 0;
+ }
if(subtree != NULL) { /* append subtree to current tree */
t2->left = LTTV_TREE_NODE;
t2->l_child.t = subtree;
subtree = NULL;
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
} else { /* append a simple expression */
lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
t2->left = LTTV_TREE_LEAF;
t2->l_child.leaf = a_simple_expression;
a_simple_expression = lttv_simple_expression_new();
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
}
break;
}
t2 = lttv_filter_tree_new();
t2->node = LTTV_LOGICAL_OR;
- if(subtree != NULL) { /* append subtree to current tree */
+ t1->right = LTTV_TREE_NODE;
+ t1->r_child.t = t2;
+ if(not) { // add not operator to tree
+ t3 = lttv_filter_tree_new();
+ t3->node = LTTV_LOGICAL_NOT;
+ t2->left = LTTV_TREE_NODE;
+ t2->l_child.t = t3;
+ t2 = t3;
+ not = 0;
+ }
+ if(subtree != NULL) { /* append subtree to current tree */
t2->left = LTTV_TREE_NODE;
t2->l_child.t = subtree;
subtree = NULL;
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
- } else { /* append a simple expression */
+ } else { /* append a simple expression */
lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
t2->left = LTTV_TREE_LEAF;
t2->l_child.leaf = a_simple_expression;
a_simple_expression = lttv_simple_expression_new();
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
}
break;
}
t2 = lttv_filter_tree_new();
t2->node = LTTV_LOGICAL_XOR;
+ t1->right = LTTV_TREE_NODE;
+ t1->r_child.t = t2;
+ if(not) { // add not operator to tree
+ t3 = lttv_filter_tree_new();
+ t3->node = LTTV_LOGICAL_NOT;
+ t2->left = LTTV_TREE_NODE;
+ t2->l_child.t = t3;
+ t2 = t3;
+ not = 0;
+ }
if(subtree != NULL) { /* append subtree to current tree */
t2->left = LTTV_TREE_NODE;
t2->l_child.t = subtree;
subtree = NULL;
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
} else { /* append a simple expression */
lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
t2->left = LTTV_TREE_LEAF;
t2->l_child.leaf = a_simple_expression;
a_simple_expression = lttv_simple_expression_new();
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
}
break;
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_NE);
i++;
} else { /* ! */
- t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1);
- while(t1->right != LTTV_TREE_IDLE) {
- g_assert(t1->right == LTTV_TREE_NODE);
- t1 = t1->r_child.t;
- }
- t2 = lttv_filter_tree_new();
- t2->node = LTTV_LOGICAL_NOT;
- t1->right = LTTV_TREE_NODE;
- t1->r_child.t = t2;
+ not=1;
}
break;
p_nesting++; /* incrementing parenthesis nesting value */
t1 = lttv_filter_tree_new();
+ if(not) { /* add not operator to tree */
+ t3 = lttv_filter_tree_new();
+ t3->node = LTTV_LOGICAL_NOT;
+ t1->right = LTTV_TREE_NODE;
+ t1->r_child.t = t3;
+ not = 0;
+ }
g_ptr_array_add( tree_stack,(gpointer) t1 );
break;
/* there must at least be the root tree left in the array */
g_assert(tree_stack->len>0);
-
+
+ t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
+ while(t1->right != LTTV_TREE_IDLE) {
+ t1 = t1->r_child.t;
+ }
+ if(not) { // add not operator to tree
+ g_print("ici");
+ t3 = lttv_filter_tree_new();
+ t3->node = LTTV_LOGICAL_NOT;
+ t1->right = LTTV_TREE_NODE;
+ t1->r_child.t = t3;
+ t1 = t3;
+ not = 0;
+ }
if(subtree != NULL) { /* append subtree to current tree */
- t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
- while(t1->right != LTTV_TREE_IDLE) {
- g_assert(t1->right == LTTV_TREE_NODE);
- t1 = t1->r_child.t;
- }
t1->right = LTTV_TREE_NODE;
t1->r_child.t = subtree;
subtree = g_ptr_array_index(tree_stack,tree_stack->len-1);
} else { /* assign subtree as current tree */
lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
a_field_component = g_string_new("");
- t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
- while(t1->right != LTTV_TREE_IDLE) {
- g_assert(t1->right == LTTV_TREE_NODE);
- g_assert(t1->r_child.t != NULL);
- t1 = t1->r_child.t;
- }
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
t1->right = LTTV_TREE_LEAF;
t1->r_child.leaf = a_simple_expression;
a_simple_expression = lttv_simple_expression_new();
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
if(filter->expression[i+1] == '=') { /* <= */
i++;
lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LE);
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
if(filter->expression[i+1] == '=') { /* >= */
i++;
lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GE);
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_EQ);
break;
if(a_simple_expression->field == LTTV_FILTER_UNDEFINED) {
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
a_field_component = g_string_new("");
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = g_string_new("");
}
break;
- case ' ': /* ignore */
+ case ' ': /* keep spaces that are within a field component */
+ if(a_field_component->len == 0) break; /* ignore */
+ else
+ a_string_spaces = g_string_append_c(a_string_spaces,
+ filter->expression[i]);
+
case '\n': /* ignore */
break;
default: /* concatening current string */
- g_string_append_c(a_field_component,filter->expression[i]);
+ if(a_string_spaces->len != 0) {
+ g_string_append(a_field_component, a_string_spaces->str);
+ a_string_spaces = g_string_set_size(a_string_spaces, 0);
+ }
+ a_field_component = g_string_append_c(a_field_component,
+ filter->expression[i]);
}
}
if(tree_stack->len != 1) /* only root tree should remain */
return FALSE;
- /* processing last element of expression */
+ /*
+ * processing last element of expression
+ */
t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
while(t1->right != LTTV_TREE_IDLE) {
g_assert(t1->right == LTTV_TREE_NODE);
t1 = t1->r_child.t;
}
+ if(not) { // add not operator to tree
+ t3 = lttv_filter_tree_new();
+ t3->node = LTTV_LOGICAL_NOT;
+ t1->right = LTTV_TREE_NODE;
+ t1->r_child.t = t3;
+ t1 = t3;
+ not = 0;
+ }
if(subtree != NULL) { /* add the subtree */
t1->right = LTTV_TREE_NODE;
t1->r_child.t = subtree;
} else { /* add a leaf */
lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
a_field_component = NULL;
+ g_string_free(a_string_spaces, TRUE);
+ a_string_spaces = NULL;
t1->right = LTTV_TREE_LEAF;
t1->r_child.leaf = a_simple_expression;
a_simple_expression = NULL;
/* free the field buffer if allocated */
if(a_field_component != NULL) g_string_free(a_field_component,TRUE);
-
+ if(a_string_spaces != NULL) g_string_free(a_string_spaces, TRUE);
+
/* free the simple expression buffer if allocated */
if(a_simple_expression != NULL) lttv_simple_expression_destroy(a_simple_expression);
g_assert(filter->head != NULL); /* tree should exist */
g_assert(subtree == NULL); /* remaining subtree should be included in main tree */
+
+#ifdef TEST
+ gettimeofday(&endtime, NULL);
+
+ /* Calcul du temps de l'algorithme */
+ double time1 = starttime.tv_sec + (starttime.tv_usec/1000000.0);
+ double time2 = endtime.tv_sec + (endtime.tv_usec/1000000.0);
+// g_print("Tree build took %.10f ms for strlen of %i\n",(time2-time1)*1000,strlen(filter->expression));
+ g_print("%.10f %i\n",(time2-time1)*1000,strlen(filter->expression));
+#endif
/* debug */
- g_print("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n");
- lttv_print_tree(filter->head) ;
- g_print("+++++++++++++++ END PRINT ++++++++++++++++++\n");
+ g_debug("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n");
+ lttv_print_tree(filter->head,0) ;
+ g_debug("+++++++++++++++ END PRINT ++++++++++++++++++\n");
/* success */
return TRUE;
void
lttv_filter_destroy(LttvFilter* filter) {
- g_free(filter->expression);
- lttv_filter_tree_destroy(filter->head);
+ if(!filter) return;
+
+ if(filter->expression)
+ g_free(filter->expression);
+ if(filter->head)
+ lttv_filter_tree_destroy(filter->head);
g_free(filter);
}
* @param expression string that must be appended
* @return Success/Failure of operation
*/
-gboolean lttv_filter_append_expression(LttvFilter* filter, const char *expression) {
+gboolean
+lttv_filter_append_expression(LttvFilter* filter, const char *expression) {
if(expression == NULL) return FALSE;
if(filter == NULL) return FALSE;
+ if(expression[0] == '\0') return FALSE; /* Empty expression */
GString* s = g_string_new("");
if(filter->expression != NULL) {
* current filter and sets its pointer to NULL
* @param filter pointer to the current LttvFilter
*/
-void lttv_filter_clear_expression(LttvFilter* filter) {
+void
+lttv_filter_clear_expression(LttvFilter* filter) {
if(filter->expression != NULL) {
g_free(filter->expression);
const LttEvent* event,
const LttTracefile* tracefile,
const LttTrace* trace,
- const LttvProcessState* state,
const LttvTracefileContext* context
/*,...*/)
{
*/
gboolean lresult = FALSE, rresult = FALSE;
+
+ LttvProcessState* state;
+
+ LttvTraceState *ts = (LttvTraceState*)context->t_context;
+ LttvTracefileState *tfs = (LttvTracefileState*)context;
+ guint cpu = tfs->cpu;
+ state = ts->running_process[cpu];
/*
* Parse left branch
*/
if(t->left == LTTV_TREE_NODE) {
- lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,state,context);
+ lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,context);
}
else if(t->left == LTTV_TREE_LEAF) {
lresult = lttv_filter_tree_parse_branch(t->l_child.leaf,event,tracefile,trace,state,context);
* Parse right branch
*/
if(t->right == LTTV_TREE_NODE) {
- rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,state,context);
+ rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,context);
}
else if(t->right == LTTV_TREE_LEAF) {
rresult = lttv_filter_tree_parse_branch(t->r_child.leaf,event,tracefile,trace,state,context);
}
-
+
+
/*
* Apply and return the
* logical link between the
switch(t->node) {
case LTTV_LOGICAL_OR: return (lresult | rresult);
case LTTV_LOGICAL_AND: return (lresult & rresult);
- case LTTV_LOGICAL_NOT: return (!rresult);
+ case LTTV_LOGICAL_NOT:
+ return (t->left==LTTV_TREE_LEAF)?!lresult:((t->right==LTTV_TREE_LEAF)?!rresult:TRUE);
case LTTV_LOGICAL_XOR: return (lresult ^ rresult);
case 0: return (rresult);
default:
* @param context current LttvTracefileContext, NULL if not used
* @return response of filter
*/
-gboolean lttv_filter_tree_parse_branch(
+gboolean
+lttv_filter_tree_parse_branch(
const LttvSimpleExpression* se,
const LttEvent* event,
const LttTracefile* tracefile,
case LTTV_FILTER_TRACE_NAME:
if(trace == NULL) return TRUE;
else {
- char* trace_name = ltt_trace_name(trace);
- GQuark quark = g_quark_from_string(trace_name);
+ GQuark quark = ltt_trace_name(trace);
return se->op((gpointer)&quark,v);
}
break;
case LTTV_FILTER_TRACEFILE_NAME:
if(tracefile == NULL) return TRUE;
else {
- char* tracefile_name = ltt_tracefile_name(tracefile);
- GQuark quark = g_quark_from_string(tracefile_name);
+ GQuark quark = ltt_tracefile_name(tracefile);
return se->op((gpointer)&quark,v);
}
break;
}
break;
case LTTV_FILTER_STATE_P_NAME:
- /*
- * All 'unnamed' for the moment
- */
if(state == NULL) return TRUE;
else {
GQuark quark = state->name;
return se->op((gpointer)&quark,v);
}
break;
+ case LTTV_FILTER_STATE_T_BRAND:
+ if(state == NULL) return TRUE;
+ else {
+ GQuark quark = state->brand;
+ return se->op((gpointer)&quark,v);
+ }
+ break;
case LTTV_FILTER_STATE_EX_MODE:
if(state == NULL) return TRUE;
else return se->op((gpointer)&state->state->t,v);
case LTTV_FILTER_STATE_CPU:
if(context == NULL) return TRUE;
else {
- /* FIXME: not sure of that one */
- GQuark quark = ((LttvTracefileState*)context)->cpu_name;
- return se->op((gpointer)&quark,v);
+ if(state == NULL) return TRUE;
+ else return se->op((gpointer)&state->cpu,v);
}
break;
case LTTV_FILTER_EVENT_NAME:
else {
LttEventType* et;
et = ltt_event_eventtype(event);
- char* event_name = ltt_eventtype_name(et);
- GQuark quark = g_quark_from_string(event_name);
+ GQuark quark = ltt_eventtype_name(et);
+ return se->op((gpointer)&quark,v);
+ }
+ break;
+ case LTTV_FILTER_EVENT_FACILITY:
+ if(event == NULL) return TRUE;
+ else {
+ LttFacility* fac;
+ fac = ltt_event_facility(event);
+ GQuark quark = ltt_facility_name(fac);
return se->op((gpointer)&quark,v);
}
break;
-
case LTTV_FILTER_EVENT_CATEGORY:
/*
* TODO: Not yet implemented
* @param t the pointer to the current LttvFilterTree
*/
void
-lttv_print_tree(const LttvFilterTree* t) {
+lttv_print_tree(const LttvFilterTree* t, const int count) {
- g_print("node:%p lchild:%p rchild:%p\n",t, //t->l_child.t,t->r_child.t);
+ g_debug("node:%p lchild:%p rchild:%p depth:%i\n",t, //t->l_child.t,t->r_child.t);
(t->left==LTTV_TREE_NODE)?t->l_child.t:NULL,
- (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL);
- g_print("node type: %i / [left] %i / [right] %i\n",t->node,t->left,t->right);
- if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t);
- else if(t->left == LTTV_TREE_LEAF) {
- g_print("%p: left is %i %p value\n",t,t->l_child.leaf->field,t->l_child.leaf->op);
+ (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL,
+ count);
+ g_debug("logic operator: %s\n",(t->node&1)?"OR":((t->node&2)?"AND":((t->node&4)?"NOT":((t->node&8)?"XOR":"IDLE"))));
+ g_debug("|-> left branch %p is a %s\n",t->l_child.t,(t->left==LTTV_TREE_NODE)?"NODE":((t->left==LTTV_TREE_LEAF)?"LEAF":"IDLE"));
+ if(t->left == LTTV_TREE_LEAF) {
+ g_debug("| |-> field type number: %i\n",t->l_child.leaf->field);
+ g_debug("| |-> offset is: %i\n",t->l_child.leaf->offset);
+ g_debug("| |-> operator function is: %p\n",t->l_child.leaf->op);
}
- if(t->right == LTTV_TREE_NODE) lttv_print_tree(t->r_child.t);
- else if(t->right == LTTV_TREE_LEAF) {
- g_print("%p: right is %i %p value\n",t,t->r_child.leaf->field,t->r_child.leaf->op);
+ g_debug("|-> right branch %p is a %s\n",t->r_child.t,(t->right==LTTV_TREE_NODE)?"NODE":((t->right==LTTV_TREE_LEAF)?"LEAF":"IDLE"));
+ if(t->right == LTTV_TREE_LEAF) {
+ g_debug("| |-> field type number: %i\n",t->r_child.leaf->field);
+ g_debug("| |-> offset is: %i\n",t->r_child.leaf->offset);
+ g_debug("| |-> operator function is: %p\n",t->r_child.leaf->op);
}
-
+
+ if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t,count+1);
+ if(t->right == LTTV_TREE_NODE) lttv_print_tree(t->r_child.t,count+1);
}
/**
projects / lttv.git / blobdiff