Pacer 1.4.0 Released!

[Darrick Wiebe]

I've spent the last few weeks pushing Pacer's limits against a very large (~ 100x larger than the previous largest I'd worked with) graph! It's been a lot of fun, and at the same time I've had the opportunity to make a number of improvements to Pacer. Here's a quick list of the changes in Pacer over the last few weeks that have resulted in v1.4.0:

Breaking Change

============

route_conditions now requires one argument (the current graph) if you define it:  module MyExt; def self.route_conditions(graph); {...}; end end

YFiles export now takes a route rather than a subgraph to export.

New Features / Improvements

======================

route.delete! returns count of number of rows deleted

lookup(graph) method can be defined, same convention as route_conditions, but only used for index lookups

YFiles export no longer creates an intermediate subgraph, making it faster and much less memory hungry. It also prints progress indicators as it runs.

graph.never_scan = true will prevent full graph scans

#is and #is_not work better, are more thread safe and work within lookaheads now.

Visitors can now skip the element wrapping step

Pacer.executing_route(route) will be called before any route is executed, enabling logging, etc.

branch / merge finall added

#join { |r| route } was rewritten, much simplified and much more functional

#intersect_sections allows you to find the commonality between the results of a section of a route.

#difference_sections, see above

#limit_section(n) allows the results from each element that enters a section to be limited. Prevents large fan-outs in some cases.

#all { |r| r.route_to_loop } standard loop pattern: loops to all depths and emits everything encountered. Does not return the entering node.

#deepest { |r| r.route_to_loop } standard loop pattern: loop to the deepest results (like only getting all leaves from the tree, no branches).

#loop_while { |r| route }, #loop_while_not { |r| route }  Use lookahead style blocks to control looping, rather than a filter style block which runs on every element.

#emit_while { |r| route }, #emit_while_not { |r| route } see above

#cond("where statement") { |r| route }, #otherwise conditional branching route, with else-style clause. Multiple conds can be used together.

Also, check out pacer-parallel, which puts Clojure's core.async to work to parallelize sections of your route definition... In some cases so far, I've seen up to 5x speedups on an 8 core box.

Enjoy!

[Steven McCraw]

Sounds like great stuff!  Thanks!

Sent from my mobile device. Apologies for brevity.

--
You received this message because you are subscribed to the Google Groups "pacer-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email to pacer-users...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

[Burak Arikan]

This is great! Can't wait to try it. 

Burak

--
You received this message because you are subscribed to the Google Groups "pacer-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email to pacer-users...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

--
Burak

burak-arikan.com