Saxon

Legacy ID: #4992675 Legacy Poster: Michael Kay (mhkay)

I personally find this kind of task MUCH easier in XSLT, which has built-in primitives for doing a recursive descent of the tree. It's also easier, I think, to make it efficient - the key to the performance of this kind of operation is to make sure you avoid repeated copying of subtrees, which will happen if the function calls are executed in push mode rather than pull mode. I suspect your "bottom-up" code was copying subtrees, and the "top-down" code wasn't, but without seeing your code I can't tell. 1. I discovered that the TimedTraceListener only records calls to my user functions. Is it possible to get a little lower and see timings for different operations in my functions? Does that require writing a custom TraceListener? You can adapt the TimedTraceListener to record more information, but I think you'll find that the information becomes unreliable at a finer level of granularity. Lazy evaluation makes it very hard to decipher the results - you can't easily distinguish the cost of doing an intersect operation from the cost of evaluating its operands, because the whole thing is pipelined. >Is there an idiom that's especially efficient in Saxon to express the equivalent of $some-sequence[ancestor::node() = $some-node], that is, the elements of $some-sequence descended from $some-node? I'm sure "=" for "is" (or "intersect") there was a slip... But it's a common mistake, and because it often gives the right answer people don't realize how costly it is (as well as being wrong, when given suitable data). It can result in comparison of very long string-values, which take a long time to assemble from all the descendant text nodes. The answer is no, there's no particularly good way of doing this. With some tree models, notably the TinyTree, there would be good strategies available, but Saxon generally avoids doing any optimizations that take account of which tree model is in use. (In general, this isn't even known at compile time.) The optimimum strategy may well be different depending on whether your filter is selecting 5% of leaf nodes or 95% of them. In the latter case you would be better off building a list of nodes that DON'T have any selected descendants rather than a list of those that DO.

Legacy ID: #4992700 Legacy Poster: Michael Kay (mhkay)

>>Is there an idiom that's especially efficient in Saxon to express the >equivalent of $some-sequence[ancestor::node() = $some-node], that is, the elements of $some-sequence descended from $some-node? One construct you could experiment with is let $start = $some-node let $end = $some-node/following::node()[1] return $some-sequence[. >> $start and not($end << .)] That should work quite well on the tinytree where "<<" and ">>" are pretty fast. (the peculiar way of coding it is so that it still works when $start is the root of the tree.) Michael Kay

Legacy ID: #4994250 Legacy Poster: Chapman Flack (jcflack)

> One construct you could experiment with is > let $start = $some-node > let $end = $some-node/following::node()[1] > return $some-sequence[. >> $start and not($end << .)] I'm happy to report that's exactly the construct I did experiment with yesterday while waiting for replies (though mine had an 'if' because I hadn't thought of not($end<<.) - that's nicer). It gave me a 15x speedup on my test document, on top of the 4x from replacing the 'intersect's with '.. is $n's earlier. A factor of 60 improvement makes a pretty fair answer to "how was work yesterday?". :) You were right that my = in the question was a slip (in the sense that I had never coded up and tested a version that used that) but I am glad you pointed it out because I had still not completely absorbed the fact that the general comparisons always atomize, and that 'intersect' there would have been the way to get the equivalent result based on node identity. Thanks, -Chap