X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=dbdb16026f63abef0d89b8fa17cefe05b6cf0b8e;hb=2ea36caf80da2b86d4b565fe3cbded286c7664d7;hp=ec457eb80fd58e67832eac72f16a2bf72f19b121;hpb=18d1226ff771cccf7bc739f980b3412d5edb82b0;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index ec457eb8..dbdb1602 100644 --- a/ltt/branches/poly/lttv/lttv/filter.c +++ b/ltt/branches/poly/lttv/lttv/filter.c @@ -28,6 +28,13 @@ * - the exists an other lttv_filter which conflicts with this one */ +/* + * TODO + * - refine switch of expression in multiple uses functions + * - remove the idle expressions in the tree **** + * - add the current simple expression to the tree + */ + #include /* @@ -72,20 +79,25 @@ GQuark LTTV_FILTER_EX_SUBMODE, LTTV_FILTER_P_STATUS, LTTV_FILTER_CPU; - + +LttvSimpleExpression* +lttv_simple_expression_new() { + +} + /** * Assign a new tree for the current expression * or sub expression - * @return pointer of lttv_filter_tree + * @return pointer of LttvFilter */ -lttv_filter_tree* lttv_filter_tree_new() { - lttv_filter_tree* tree; +LttvFilter* lttv_filter_tree_new() { + LttvFilter* tree; - tree = g_new(lttv_filter_tree,1); - tree->node = g_new(lttv_expression,1); - tree->node->type = LTTV_UNDEFINED_EXPRESSION; - tree->left = LTTV_TREE_UNDEFINED; - tree->right = LTTV_TREE_UNDEFINED; + tree = g_new(LttvFilter,1); + tree->node = 0; //g_new(lttv_expression,1); +// tree->node->type = LTTV_UNDEFINED_EXPRESSION; + tree->left = LTTV_TREE_IDLE; + tree->right = LTTV_TREE_IDLE; return tree; } @@ -94,7 +106,7 @@ lttv_filter_tree* lttv_filter_tree_new() { * Destroys the tree and his sub-trees * @param tree Tree which must be destroyed */ -void lttv_filter_tree_destroy(lttv_filter_tree* tree) { +void lttv_filter_tree_destroy(LttvFilter* tree) { if(tree->left == LTTV_TREE_LEAF) g_free(tree->l_child.leaf); else if(tree->left == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->l_child.t); @@ -106,6 +118,47 @@ void lttv_filter_tree_destroy(lttv_filter_tree* tree) { g_free(tree); } +LttvFilter* +lttv_filter_clone(LttvFilter* tree) { + + LttvFilter* newtree = lttv_filter_tree_new(); + + /* + * TODO : Copy tree into new tree + */ + + return newtree; + +} + +void +lttv_filter_tree_add_node(GPtrArray* stack, LttvFilter* subtree, LttvLogicalOp op) { + + LttvFilter* t1 = NULL; + LttvFilter* t2 = NULL; + + t1 = (LttvFilter*)g_ptr_array_index(stack,stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t2 = lttv_filter_tree_new(); + t2->node = op; + if(subtree != NULL) { + t2->left = LTTV_TREE_NODE; + t2->l_child.t = subtree; + subtree = NULL; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } else { +// a_simple_expression->value = a_field_component->str; +// a_field_component = g_string_new(""); + t2->left = LTTV_TREE_LEAF; +// t2->l_child.leaf = a_simple_expression; +// a_simple_expression = g_new(lttv_simple_expression,1); + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } + +} + /** * Parse through filtering field hierarchy as specified * by user. This function compares each value to @@ -117,16 +170,43 @@ gboolean parse_field_path(GPtrArray* fp) { GString* f = NULL; + if(fp->len < 2) return FALSE; g_assert(f=g_ptr_array_index(fp,0)); //list_first(fp)->data; if(g_quark_try_string(f->str) == LTTV_FILTER_EVENT) { -// parse_subfield(fp, LTTV_FILTER_EVENT); + f=g_ptr_array_index(fp,1); + if(g_quark_try_string(f->str) == LTTV_FILTER_NAME) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_CATEGORY) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_TIME) { + // offset = &((LttEvent*)NULL)->event_time); + } + else if(g_quark_try_string(f->str) == LTTV_FILTER_TSC) { + // offset = &((LttEvent*)NULL)->event_cycle_count); + } + else { /* core.xml specified options */ + } } else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACEFILE) { - + f=g_ptr_array_index(fp,1); + if(g_quark_try_string(f->str) == LTTV_FILTER_NAME) {} + else return FALSE; } else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACE) { + f=g_ptr_array_index(fp,1); + if(g_quark_try_string(f->str) == LTTV_FILTER_NAME) {} + else return FALSE; } else if(g_quark_try_string(f->str) == LTTV_FILTER_STATE) { + f=g_ptr_array_index(fp,1); + if(g_quark_try_string(f->str) == LTTV_FILTER_PID) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_PPID) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_C_TIME) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_I_TIME) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_P_NAME) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_EX_MODE) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_EX_SUBMODE) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_P_STATUS) {} + else if(g_quark_try_string(f->str) == LTTV_FILTER_CPU) {} + else return FALSE; } else { g_warning("Unrecognized field in filter string"); @@ -156,7 +236,7 @@ parse_simple_expression(GString* expression) { * @param t pointer to the current LttvTrace * @return the current lttv_filter or NULL if error */ -lttv_filter_tree* +LttvFilter* lttv_filter_new(char *expression, LttvTraceState *tcs) { g_print("filter::lttv_filter_new()\n"); /* debug */ @@ -165,19 +245,23 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { i, p_nesting=0, /* parenthesis nesting value */ b=0; /* current breakpoint in expression string */ - - /* - * Main tree & Tree concatening list + + /* trees */ + LttvFilter + *tree = lttv_filter_tree_new(), /* main tree */ + *subtree = NULL, /* buffer for subtrees */ + *t1, /* buffer #1 */ + *t2; /* buffer #2 */ + + /* + * Tree Stack * each element of the list * is a sub tree created * by the use of parenthesis in the * global expression. The final tree - * will be the one created at the root of + * will be the one left at the root of * the list */ - lttv_filter_tree* tree = lttv_filter_tree_new(); - lttv_filter_tree* subtree = NULL; -// lttv_filter_tree* current_tree = NULL; GPtrArray *tree_stack = g_ptr_array_new(); g_ptr_array_add( tree_stack,(gpointer) tree ); @@ -185,7 +269,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { GString *a_field_component = g_string_new(""); GPtrArray *a_field_path = NULL; - lttv_simple_expression a_simple_expression; + LttvSimpleExpression* a_simple_expression = g_new(LttvSimpleExpression,1); /* * Parse entire expression and construct @@ -199,9 +283,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { * To spare computing time, the whole * string is parsed in this loop for a * O(n) complexity order. - */ - - /* + * * When encountering logical op &,|,^ * 1. parse the last value if any * 2. create a new tree @@ -223,56 +305,102 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { a_field_path = g_ptr_array_new(); g_ptr_array_set_size(a_field_path,2); /* by default, recording 2 field expressions */ - lttv_filter_tree *t1, *t2; for(i=0;istr); - g_print("%c\n",expression[i]); + g_print("%c ",expression[i]); +// g_print("switch:%c -->subtree:%p\n",expression[i],subtree); switch(expression[i]) { /* * logical operators */ case '&': /* and */ - t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t2 = lttv_filter_tree_new(); - t2->node->type = LTTV_EXPRESSION_OP; - t2->node->e.op = LTTV_LOGICAL_AND; - if(subtree != NULL) { + t2->node = LTTV_LOGICAL_AND; + if(subtree != NULL) { t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; subtree = NULL; t1->right = LTTV_TREE_NODE; - t1->l_child.t = t2; + t1->r_child.t = t2; } else { - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; - t2->l_child.leaf = g_new(lttv_simple_expression,1); + t2->l_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); t1->right = LTTV_TREE_NODE; - t1->l_child.t = t2; + t1->r_child.t = t2; } break; case '|': /* or */ + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t2 = lttv_filter_tree_new(); + t2->node = LTTV_LOGICAL_OR; + if(subtree != NULL) { + t2->left = LTTV_TREE_NODE; + t2->l_child.t = subtree; + subtree = NULL; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } else { + a_simple_expression->value = a_field_component->str; + a_field_component = g_string_new(""); + t2->left = LTTV_TREE_LEAF; + t2->l_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } break; case '^': /* xor */ + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t2 = lttv_filter_tree_new(); + t2->node = LTTV_LOGICAL_XOR; + if(subtree != NULL) { + t2->left = LTTV_TREE_NODE; + t2->l_child.t = subtree; + subtree = NULL; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } else { + a_simple_expression->value = a_field_component->str; + a_field_component = g_string_new(""); + t2->left = LTTV_TREE_LEAF; + t2->l_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } break; case '!': /* not, or not equal (math op) */ if(expression[i+1] == '=') { /* != */ - a_simple_expression.op = LTTV_FIELD_NE; + a_simple_expression->op = LTTV_FIELD_NE; i++; + g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + a_field_component = g_string_new(""); } else { /* ! */ - g_print("%s\n",a_field_component); - a_field_component = g_string_new(""); + // g_print("%s\n",a_field_component); + // a_field_component = g_string_new(""); + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) 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; } break; case '(': /* start of parenthesis */ case '[': case '{': p_nesting++; /* incrementing parenthesis nesting value */ - lttv_filter_tree* subtree = lttv_filter_tree_new(); - g_ptr_array_add( tree_stack,(gpointer) subtree ); + t1 = lttv_filter_tree_new(); + g_ptr_array_add( tree_stack,(gpointer) t1 ); break; case ')': /* end of parenthesis */ case ']': @@ -287,8 +415,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { g_assert(tree_stack->len>0); if(subtree != NULL) { t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - /* FIXME ==> SEG FAULT */ - while(t1->right != LTTV_TREE_UNDEFINED && t1->right != LTTV_TREE_LEAF) { + while(t1->right != LTTV_TREE_IDLE && t1->right != LTTV_TREE_LEAF) { g_assert(t1!=NULL && t1->r_child.t != NULL); t1 = t1->r_child.t; } @@ -297,29 +424,17 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); g_ptr_array_remove_index(tree_stack,tree_stack->len-1); } else { - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t1->right = LTTV_TREE_LEAF; - t1->r_child.leaf = g_new(lttv_simple_expression,1); + t1->r_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); + g_assert(subtree != NULL); g_ptr_array_remove_index(tree_stack,tree_stack->len-1); } - /* lttv_filter_tree *sub1 = g_ptr_array_index(tree_list,tree_list->len-1); - lttv_filter_tree *sub2 = g_ptr_array_index(tree_list,tree_list->len); - if(sub1->left == LTTV_TREE_UNDEFINED){ - sub1->l_child.t = sub2; - sub1->left = LTTV_TREE_NODE; - } else if(sub1->right == LTTV_TREE_UNDEFINED){ - sub1->r_child.t = sub2; - sub1->right = LTTV_TREE_NODE; - } else g_error("error during tree assignation"); - g_ptr_array_remove_index(tree_list,tree_list->len); - break; - */ - // subtree = g_ptr_array_index(tree_stack,tree_stack->len); - // g_ptr_array_remove_index(tree_stack,tree_stack->len); break; /* @@ -328,21 +443,21 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { case '<': /* lower, lower or equal */ if(expression[i+1] == '=') { /* <= */ i++; - a_simple_expression.op = LTTV_FIELD_LE; - } else a_simple_expression.op = LTTV_FIELD_LT; + a_simple_expression->op = LTTV_FIELD_LE; + } else a_simple_expression->op = LTTV_FIELD_LT; g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); break; case '>': /* higher, higher or equal */ if(expression[i+1] == '=') { /* >= */ i++; - a_simple_expression.op = LTTV_FIELD_GE; - } else a_simple_expression.op = LTTV_FIELD_GT; + a_simple_expression->op = LTTV_FIELD_GE; + } else a_simple_expression->op = LTTV_FIELD_GT; g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); break; case '=': /* equal */ - a_simple_expression.op = LTTV_FIELD_EQ; + a_simple_expression->op = LTTV_FIELD_EQ; g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); break; @@ -358,13 +473,53 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { } } + g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree,tree,t1,t2); + g_print("stack size: %i\n",tree_stack->len); - + /* + * Preliminary check to see + * if tree was constructed correctly + */ if( p_nesting>0 ) { g_warning("Wrong filtering options, the string\n\"%s\"\n\ is not valid due to parenthesis incorrect use",expression); return NULL; } + + if(tree_stack->len != 1) /* only root tree should remain */ + return NULL; + + /* processing last element of expression */ + t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + if(subtree != NULL) { /* add the subtree */ + t1->right = LTTV_TREE_NODE; + t1->r_child.t = subtree; + subtree = NULL; + } else { /* add a leaf */ + a_simple_expression->value = a_field_component->str; + a_field_component = g_string_new(""); + t1->right = LTTV_TREE_LEAF; + t1->r_child.leaf = a_simple_expression; + /* + * FIXME: is it really necessary to reallocate + * LttvSimpleExpression at this point ?? + */ + a_simple_expression = g_new(LttvSimpleExpression,1); + } + + g_assert(tree != NULL); + g_assert(subtree == NULL); + + lttv_filter_tracefile(tree,NULL); + + return tree; + +} + +void +lttv_filter_destroy(LttvFilter* filter) { + } /** @@ -374,9 +529,31 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { * @return success/failure of operation */ gboolean -lttv_filter_tracefile(lttv_filter_t *filter, LttTracefile *tracefile) { +lttv_filter_tracefile(LttvFilter *filter, LttTracefile *tracefile) { + /* + * Each tree is parsed in inorder. + * This way, it's possible to apply the left filter of the + * tree, then decide whether or not the right branch should + * be parsed depending on the linking logical operator + * + * As for the filtering structure, since we are trying + * to remove elements from the trace, it might be better + * managing an array of all items to be removed .. + */ + g_print("node:%p lchild:%p rchild:%p\n",filter,filter->l_child.t,filter->r_child.t); + g_print("node type%i\n",filter->node); + if(filter->left == LTTV_TREE_NODE) lttv_filter_tracefile(filter->l_child.t,NULL); + else if(filter->left == LTTV_TREE_LEAF) { + g_assert(filter->l_child.leaf->value != NULL); + g_print("%p: left is qqch %i %s\n",filter,filter->l_child.leaf->op,filter->l_child.leaf->value); + } + if(filter->right == LTTV_TREE_NODE) lttv_filter_tracefile(filter->r_child.t,NULL); + else if(filter->right == LTTV_TREE_LEAF) { + g_assert(filter->r_child.leaf->value != NULL); + g_print("%p: right is qqch %i %s\n",filter,filter->r_child.leaf->op,filter->r_child.leaf->value); + } /* test */ /* int i, nb; @@ -405,7 +582,7 @@ lttv_filter_tracefile(lttv_filter_t *filter, LttTracefile *tracefile) { } gboolean -lttv_filter_tracestate(lttv_filter_t *filter, LttvTraceState *tracestate) { +lttv_filter_tracestate(LttvFilter *filter, LttvTraceState *tracestate) { } @@ -416,7 +593,7 @@ lttv_filter_tracestate(lttv_filter_t *filter, LttvTraceState *tracestate) { * @return success/failure of operation */ gboolean -lttv_filter_event(lttv_filter_t *filter, LttEvent *event) { +lttv_filter_event(LttvFilter *filter, LttEvent *event) { }