if (node == NULLT)
return 0;
else {
- return /*1+iterjump(tree,tree->TaggedDescendant(node,tag),tag,node)
- +*/ iterjump(tree,tree->TaggedFollowingBelow(node,tag,anc),tag,anc);
+ return
+ 1
+ + iterjump(tree,tree->TaggedDescendant(node,tag),tag,node)
+ + iterjump(tree,tree->TaggedFollowingBelow(node,tag,anc),tag,anc);
};
}
return 0;
else {
int tmp = 1;
- tmp += iterfcns(tree,tree->FirstElement(node));
- tmp += iterfcns(tree,tree->NextElement(node));
+ tmp += iterfcns(tree,tree->FirstChild(node));
+ tmp += iterfcns(tree,tree->NextSibling(node));
+ return tmp;
+ };
+}
+
+int iterfene(XMLTree* tree, treeNode node){
+ if (node == NULLT)
+ return 0;
+ else {
+ int tmp = 1;
+ tmp += iterfene(tree,tree->FirstElement(node));
+ tmp += iterfene(tree,tree->NextElement(node));
return tmp;
};
}
}
+extern "C" value caml_benchmark_fene(value tree){
+ int i = iterfene(XMLTREE(tree),0);
+ return Val_int(i);
+
+}
+
int iterlcps(XMLTree* tree, treeNode node){
if (node == NULLT)
return 0;
};
}
+int fulliterative(XMLTree* tree){
+ treeNode current = tree->Root();
+ treeNode next = NULLT;
+ int count = 1; //the root
+
+ do {
+
+
+ while ((next = tree->FirstChild(current)) != NULLT) {
+ current = next;
+ count++;
+ };
+
+ while ( (next = tree->NextSibling(current)) == NULLT){
+ current = tree->Parent(current);
+ if (current == NULLT) return count;
+ }
+ current = next;
+ count++;
+ } while (true);
+
+}
+
+extern "C" value caml_benchmark_iter(value tree){
+ return Val_int(fulliterative(XMLTREE(tree)));
+}
+
extern "C" value caml_benchmark_lcps(value tree){
iterlcps(XMLTREE(tree),0);
return Val_unit;
return;
}
- dummy_node * create_tree(XMLTree* tree, treeNode i){
+ dummy_node * create_tree(XMLTree* tree, treeNode i, int mode){
if (i == NULLT)
return NULL;
else {
dummy_node * f, *n, *r;
- f = create_tree(tree,tree->FirstChild(i));
- n = create_tree(tree,tree->NextSibling(i));
- r = new_dummy_node();
+ //mode = i % 3;
+ if (mode == 0) r = new_dummy_node();
+ f = create_tree(tree,tree->FirstChild(i), mode);
+ if (mode == 1) r = new_dummy_node();
+ n = create_tree(tree,tree->NextSibling(i), mode);
+ if (mode == 2) r = new_dummy_node();
r->first = f;
r->next = n;
return r;
int iter_tree(dummy_node * n){
if (n == NULL)
return 0;
- else {
- return (1+ iter_tree(n->next)+ iter_tree(n->first) );
- };
+ else
+ return 1 + iter_tree (n->first) + iter_tree (n->next);
}
-
}
-extern "C" value caml_build_pointers(value tree){
- return ((value) create_tree(XMLTREE(Field(tree,0)),0));
+extern "C" value caml_build_pointers(value tree, value mode){
+ return ((value) create_tree(XMLTREE(Field(tree,0)),0, Int_val(mode)));
}
extern "C" value caml_iter_pointers (value node){
let benchmark_jump t s = benchmark_jump t.doc s
external benchmark_fcns : tree -> int = "caml_benchmark_fcns" "noalloc"
+external benchmark_fene : tree -> int = "caml_benchmark_fene" "noalloc"
+external benchmark_iter : tree -> int = "caml_benchmark_iter" "noalloc"
let benchmark_fcns t = benchmark_fcns t.doc
+let benchmark_fene t = benchmark_fene t.doc
+
+let benchmark_iter t = benchmark_iter t.doc
+
external benchmark_lcps : tree -> unit = "caml_benchmark_lcps" "noalloc"
let benchmark_lcps t = benchmark_lcps t.doc
let first_child t = let doc = t.doc in ();fun n -> tree_first_child doc n
let first_element t = let doc = t.doc in (); fun n -> tree_first_element doc n
-
+let first_element t n = tree_first_element t.doc n
(* these function will be called in two times: first partial application
on the tag, then application of the tag and the tree, then application of
the other arguments. We use the trick to let the compiler optimize application
let next_sibling t = let doc = t.doc in (); fun n -> tree_next_sibling doc n
let next_element t = let doc = t.doc in (); fun n -> tree_next_element doc n
+let next_element t n = tree_next_element t.doc n
let tagged_following_sibling t tag = (); fun n -> tree_tagged_following_sibling t.doc n tag