X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=a614909ed7541026948a7669bf952a338257ee4c;hb=c607371be079c36e281398a753221002c1c4c851;hp=bed1b48978f495349ed42251fefffc4cc6237b8a;hpb=786c5c3b1be5e8f6fc63e07dea07482e4fb4fd1d;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index bed1b489..a614909e 100644 --- a/ltt/branches/poly/lttv/lttv/filter.c +++ b/ltt/branches/poly/lttv/lttv/filter.c @@ -45,25 +45,39 @@ * |->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) * |->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 +#endif + +//#define TEST +#ifdef TEST +#include +#include +#endif + #include +#include +#include +#include +#include /** * @fn LttvSimpleExpression* lttv_simple_expression_new() @@ -99,7 +113,7 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { 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 @@ -234,7 +248,8 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { * @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) { /* @@ -244,7 +259,9 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx case LTTV_FILTER_TRACEFILE_NAME: case LTTV_FILTER_STATE_P_NAME: case LTTV_FILTER_EVENT_NAME: - case LTTV_FILTER_STATE_CPU: + 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; @@ -260,11 +277,6 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx /* * integer */ - 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: switch(op) { case LTTV_FIELD_EQ: @@ -290,6 +302,59 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx return FALSE; } break; + /* + * unsigned integers + */ + 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_uint; + break; + case LTTV_FIELD_NE: + 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"); + 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 */ @@ -336,39 +401,46 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx * @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_EVENT_NAME: - case LTTV_FILTER_STATE_CPU: -// se->value.v_string = value; + 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_uint32 = 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 */ @@ -386,14 +458,14 @@ gboolean lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* val /* 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); @@ -474,6 +546,22 @@ lttv_struct_type(gint ft) { } } +/** + * @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) * @@ -557,7 +645,7 @@ gboolean lttv_apply_op_eq_string(const gpointer v1, LttvFieldValue v2) { */ 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); +// g_print("v1:%i v2:%i\n",*r,v2.v_uint32); return (*r == v2.v_uint32); } @@ -575,6 +663,19 @@ gboolean lttv_apply_op_eq_ltttime(const gpointer v1, LttvFieldValue v2) { 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) @@ -675,6 +776,19 @@ gboolean lttv_apply_op_ne_ltttime(const gpointer v1, LttvFieldValue v2) { 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) @@ -747,6 +861,19 @@ gboolean lttv_apply_op_lt_ltttime(const gpointer v1, LttvFieldValue v2) { 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) @@ -820,6 +947,20 @@ gboolean lttv_apply_op_le_ltttime(const gpointer v1, LttvFieldValue v2) { } +/** + * @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) * @@ -891,6 +1032,19 @@ gboolean lttv_apply_op_gt_ltttime(const gpointer v1, LttvFieldValue v2) { 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) @@ -1011,7 +1165,9 @@ lttv_filter_tree_clone(const LttvFilterTree* tree) { */ LttvFilter* lttv_filter_clone(const LttvFilter* filter) { - + + if(!filter) return NULL; + LttvFilter* newfilter = g_new(LttvFilter,1); strcpy(newfilter->expression,filter->expression); @@ -1057,14 +1213,16 @@ lttv_filter_update(LttvFilter* filter) { 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 @@ -1123,38 +1281,53 @@ lttv_filter_update(LttvFilter* filter) { * 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;iexpression);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(""); 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; @@ -1167,20 +1340,26 @@ lttv_filter_update(LttvFilter* filter) { } 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(""); 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; @@ -1193,20 +1372,26 @@ lttv_filter_update(LttvFilter* filter) { } 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(""); 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; @@ -1219,15 +1404,7 @@ lttv_filter_update(LttvFilter* filter) { 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; @@ -1237,6 +1414,13 @@ lttv_filter_update(LttvFilter* filter) { 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; @@ -1253,13 +1437,21 @@ lttv_filter_update(LttvFilter* filter) { /* 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); @@ -1267,12 +1459,6 @@ lttv_filter_update(LttvFilter* filter) { } 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; - } t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); @@ -1350,12 +1536,22 @@ lttv_filter_update(LttvFilter* filter) { 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; @@ -1385,11 +1581,21 @@ lttv_filter_update(LttvFilter* filter) { 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; @@ -1405,8 +1611,12 @@ lttv_filter_update(LttvFilter* filter) { 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); } @@ -1441,10 +1651,12 @@ lttv_filter_tree_new() { * @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) { @@ -1468,7 +1680,8 @@ gboolean lttv_filter_append_expression(LttvFilter* filter, const char *expressio * 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); @@ -1515,7 +1728,6 @@ lttv_filter_tree_parse( const LttEvent* event, const LttTracefile* tracefile, const LttTrace* trace, - const LttvProcessState* state, const LttvTracefileContext* context /*,...*/) { @@ -1556,12 +1768,18 @@ lttv_filter_tree_parse( */ gboolean lresult = FALSE, rresult = FALSE; + + LttvProcessState* state; + + guint cpu = ltt_tracefile_num(context->tf); + LttvTraceState *ts = (LttvTraceState*)context->t_context; + 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); @@ -1578,12 +1796,13 @@ lttv_filter_tree_parse( * 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 @@ -1592,7 +1811,8 @@ lttv_filter_tree_parse( 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: @@ -1616,7 +1836,8 @@ lttv_filter_tree_parse( * @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, @@ -1630,16 +1851,14 @@ gboolean lttv_filter_tree_parse_branch( 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; @@ -1688,9 +1907,11 @@ gboolean lttv_filter_tree_parse_branch( 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); + /* FIXME: not sure of that one Mathieu : fixed.*/ + // 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: @@ -1698,8 +1919,7 @@ gboolean lttv_filter_tree_parse_branch( 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; @@ -1753,21 +1973,28 @@ gboolean lttv_filter_tree_parse_branch( * @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); } /**