[m-rev.] for review: speedup up tree_bitset.difference
Zoltan Somogyi
zs at csse.unimelb.edu.au
Fri Aug 5 12:30:40 AEST 2011
library/tree_bitset.m:
Speed up tree_bitset.difference by tailoring its actions to the forms
of the input operands, instead of its previous approach of transforming
every operand into the same general form.
Zoltan.
cvs diff: Diffing .
cvs diff: Diffing analysis
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/doc
cvs diff: Diffing boehm_gc/extra
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/extra
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing boehm_gc/libatomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops/doc
cvs diff: Diffing boehm_gc/libatomic_ops/src
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/armcc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/gcc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/hpc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/ibmc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/icc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/msftc
cvs diff: Diffing boehm_gc/libatomic_ops/src/atomic_ops/sysdeps/sunc
cvs diff: Diffing boehm_gc/libatomic_ops/tests
cvs diff: Diffing boehm_gc/libatomic_ops-1.2
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/doc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/tests
cvs diff: Diffing boehm_gc/m4
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
cvs diff: Diffing compiler/notes
cvs diff: Diffing deep_profiler
cvs diff: Diffing deep_profiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/base64
cvs diff: Diffing extras/cgi
cvs diff: Diffing extras/complex_numbers
cvs diff: Diffing extras/complex_numbers/samples
cvs diff: Diffing extras/complex_numbers/tests
cvs diff: Diffing extras/curs
cvs diff: Diffing extras/curs/samples
cvs diff: Diffing extras/curses
cvs diff: Diffing extras/curses/sample
cvs diff: Diffing extras/dynamic_linking
cvs diff: Diffing extras/error
cvs diff: Diffing extras/fixed
cvs diff: Diffing extras/gator
cvs diff: Diffing extras/gator/generations
cvs diff: Diffing extras/gator/generations/1
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/easyx
cvs diff: Diffing extras/graphics/easyx/samples
cvs diff: Diffing extras/graphics/mercury_allegro
cvs diff: Diffing extras/graphics/mercury_allegro/examples
cvs diff: Diffing extras/graphics/mercury_allegro/samples
cvs diff: Diffing extras/graphics/mercury_allegro/samples/demo
cvs diff: Diffing extras/graphics/mercury_allegro/samples/mandel
cvs diff: Diffing extras/graphics/mercury_allegro/samples/pendulum2
cvs diff: Diffing extras/graphics/mercury_allegro/samples/speed
cvs diff: Diffing extras/graphics/mercury_cairo
cvs diff: Diffing extras/graphics/mercury_cairo/samples
cvs diff: Diffing extras/graphics/mercury_cairo/samples/data
cvs diff: Diffing extras/graphics/mercury_cairo/tutorial
cvs diff: Diffing extras/graphics/mercury_glut
cvs diff: Diffing extras/graphics/mercury_opengl
cvs diff: Diffing extras/graphics/mercury_tcltk
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/gears
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing extras/graphics/samples/pent
cvs diff: Diffing extras/lazy_evaluation
cvs diff: Diffing extras/lex
cvs diff: Diffing extras/lex/samples
cvs diff: Diffing extras/lex/tests
cvs diff: Diffing extras/log4m
cvs diff: Diffing extras/logged_output
cvs diff: Diffing extras/monte
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
cvs diff: Diffing extras/moose/tests
cvs diff: Diffing extras/mopenssl
cvs diff: Diffing extras/morphine
cvs diff: Diffing extras/morphine/non-regression-tests
cvs diff: Diffing extras/morphine/scripts
cvs diff: Diffing extras/morphine/source
cvs diff: Diffing extras/net
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/posix/samples
cvs diff: Diffing extras/quickcheck
cvs diff: Diffing extras/quickcheck/tutes
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/solver_types
cvs diff: Diffing extras/solver_types/library
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/windows_installer_generator
cvs diff: Diffing extras/windows_installer_generator/sample
cvs diff: Diffing extras/windows_installer_generator/sample/images
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing extras/xml_stylesheets
cvs diff: Diffing java
cvs diff: Diffing java/runtime
cvs diff: Diffing library
Index: library/tree_bitset.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/tree_bitset.m,v
retrieving revision 1.14
diff -u -b -r1.14 tree_bitset.m
--- library/tree_bitset.m 4 Aug 2011 02:01:36 -0000 1.14
+++ library/tree_bitset.m 5 Aug 2011 02:27:07 -0000
@@ -2120,13 +2120,13 @@
LeafNodesA = [],
List = ListA
;
- LeafNodesA = [FirstNodeA | LaterNodesA],
- raise_leaves_to_level(LevelB, FirstNodeA, LaterNodesA,
- InteriorNodeA),
- head_and_tail(InteriorNodesB, InteriorHeadB, InteriorTailB),
- interiornode_difference(LevelB, InteriorNodeA, [],
- LevelB, InteriorHeadB, InteriorTailB, Level, InteriorNodes),
- List = interior_list(Level, InteriorNodes)
+ LeafNodesA = [FirstNodeA | _LaterNodesA],
+ range_of_parent_node(FirstNodeA ^ leaf_offset, 0,
+ ParentInitOffsetA, ParentLimitOffsetA),
+ find_leaf_nodes_at_parent_offset(LevelB, InteriorNodesB,
+ ParentInitOffsetA, ParentLimitOffsetA, LeafNodesB),
+ leaflist_difference(LeafNodesA, LeafNodesB, LeafNodes),
+ List = leaf_list(LeafNodes)
)
;
ListA = interior_list(LevelA, InteriorNodesA),
@@ -2136,31 +2136,340 @@
List = ListA
;
LeafNodesB = [FirstNodeB | LaterNodesB],
- raise_leaves_to_level(LevelA, FirstNodeB, LaterNodesB,
- InteriorNodeB),
- head_and_tail(InteriorNodesA, InteriorHeadA, InteriorTailA),
- interiornode_difference(LevelA, InteriorHeadA, InteriorTailA,
- LevelA, InteriorNodeB, [], Level, InteriorNodes),
+ raise_leaves_to_interior(FirstNodeB, LaterNodesB, InteriorNodeB),
+ descend_and_difference_one(LevelA, InteriorNodesA,
+ 1, InteriorNodeB, Level, InteriorNodes),
List = interior_list(Level, InteriorNodes)
)
;
ListA = interior_list(LevelA, InteriorNodesA),
ListB = interior_list(LevelB, InteriorNodesB),
+ ( LevelA > LevelB ->
+ head_and_tail(InteriorNodesB, InteriorHeadB, InteriorTailB),
+ descend_and_difference_list(LevelA, InteriorNodesA,
+ LevelB, InteriorHeadB, InteriorTailB, Level, InteriorNodes),
+ List = interior_list(Level, InteriorNodes)
+ ; LevelA = LevelB ->
head_and_tail(InteriorNodesA, InteriorHeadA, InteriorTailA),
head_and_tail(InteriorNodesB, InteriorHeadB, InteriorTailB),
-
- int.max(LevelA, LevelB, LevelAB),
- raise_interiors_to_level(LevelAB, LevelA, InteriorHeadA, InteriorTailA,
- RaisedHeadA, RaisedTailA),
- raise_interiors_to_level(LevelAB, LevelB, InteriorHeadB, InteriorTailB,
- RaisedHeadB, RaisedTailB),
- interiornode_difference(LevelAB, RaisedHeadA, RaisedTailA,
- LevelAB, RaisedHeadB, RaisedTailB, Level, InteriorNodes),
+ interiornode_difference(LevelA, InteriorHeadA, InteriorTailA,
+ LevelB, InteriorHeadB, InteriorTailB, Level, InteriorNodes),
+ List = interior_list(Level, InteriorNodes)
+ ;
+ % LevelA < LevelB
+ head_and_tail(InteriorNodesA, InteriorHeadA, InteriorTailA),
+ range_of_parent_node(InteriorHeadA ^ init_offset, LevelA,
+ ParentInitOffsetA, ParentLimitOffsetA),
+ find_interior_nodes_at_parent_offset(LevelB, InteriorNodesB,
+ LevelA+1, ParentInitOffsetA, ParentLimitOffsetA,
+ SelectedNodesB),
+ (
+ SelectedNodesB = [],
+ List = ListA
+ ;
+ SelectedNodesB = [SelectedHeadB | SelectedTailB],
+ interiornode_difference(LevelA, InteriorHeadA, InteriorTailA,
+ LevelA, SelectedHeadB, SelectedTailB,
+ Level, InteriorNodes),
List = interior_list(Level, InteriorNodes)
+ )
+ )
),
prune_top_levels(List, PrunedList),
Set = wrap_tree_bitset(PrunedList).
+:- pred find_leaf_nodes_at_parent_offset(int::in, list(interior_node)::in,
+ int::in, int::in, list(leaf_node)::out) is det.
+
+find_leaf_nodes_at_parent_offset(_LevelB, [],
+ _ParentInitOffsetA, _ParentLimitOffsetA, []).
+find_leaf_nodes_at_parent_offset(LevelB, [HeadB | TailB],
+ ParentInitOffsetA, ParentLimitOffsetA, LeafNodesB) :-
+ ( HeadB ^ init_offset > ParentInitOffsetA ->
+ % The leaf nodes in ListA cover at most one level 1 interior's node
+ % span of bits. HeadB ^ init_offset should be a multiple of (a power
+ % of) that span, so if it is greater than the initial offset of a
+ % hypothetical level 1 interior node covering ListA's leaf nodes,
+ % then it should be greater the final offset of that hypothetical
+ % node as well. The limit offset is one bigger than the final offset.
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ ( HeadB ^ init_offset >= ParentLimitOffsetA ->
+ true
+ ;
+ unexpected($module, $pred, "screwed-up offsets")
+ )
+ ),
+ LeafNodesB = []
+ ; ParentInitOffsetA < HeadB ^ limit_offset ->
+ % ListA's range is inside HeadB's range.
+ HeadNodeListB = HeadB ^ components,
+ (
+ HeadNodeListB = leaf_list(HeadLeafNodesB),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect(unify(LevelB, 1), $module, $pred, "LevelB != 1")
+ ),
+ LeafNodesB = HeadLeafNodesB
+ ;
+ HeadNodeListB = interior_list(HeadSubLevelB, HeadInteriorNodesB),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect_not(unify(LevelB, 1), $module, $pred, "LevelB = 1"),
+ expect(unify(HeadSubLevelB, LevelB - 1),
+ $module, $pred, "HeadSubLevelB != LevelB - 1")
+ ),
+ find_leaf_nodes_at_parent_offset(HeadSubLevelB, HeadInteriorNodesB,
+ ParentInitOffsetA, ParentLimitOffsetA, LeafNodesB)
+ )
+ ;
+ find_leaf_nodes_at_parent_offset(LevelB, TailB,
+ ParentInitOffsetA, ParentLimitOffsetA, LeafNodesB)
+ ).
+
+:- pred find_interior_nodes_at_parent_offset(int::in, list(interior_node)::in,
+ int::in, int::in, int::in, list(interior_node)::out) is det.
+
+find_interior_nodes_at_parent_offset(_LevelB, [],
+ _ParentLevelA, _ParentInitOffsetA, _ParentLimitOffsetA, []).
+find_interior_nodes_at_parent_offset(LevelB, [HeadB | TailB],
+ ParentLevelA, ParentInitOffsetA, ParentLimitOffsetA, NodesB) :-
+ ( LevelB > ParentLevelA ->
+ ( HeadB ^ init_offset > ParentInitOffsetA ->
+ % ListA's range is before HeadB's range.
+ % The nodes in ListA cover at most one level ParentLevelA span
+ % of bits. HeadB ^ init_offset should be a multiple of (a power of)
+ % that span, so if it is greater than the initial offset of a
+ % hypothetical level ParentLevelA interior node covering ListA's
+ % interior nodes, then it should be greater the final offset
+ % of that hypothetical node as well. The limit offset is one bigger
+ % than the final offset.
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ ( HeadB ^ init_offset >= ParentLimitOffsetA ->
+ true
+ ;
+ unexpected($module, $pred, "screwed-up offsets")
+ )
+ ),
+ NodesB = []
+ ; ParentInitOffsetA < HeadB ^ limit_offset ->
+ % ListA's range is inside HeadB's range.
+ HeadNodeListB = HeadB ^ components,
+ (
+ HeadNodeListB = leaf_list(_),
+ unexpected($module, $pred, "HeadNodeListB is a leaf list")
+ ;
+ HeadNodeListB = interior_list(HeadSubLevelB,
+ HeadInteriorNodesB),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect_not(unify(LevelB, 1), $module, $pred, "LevelB = 1"),
+ expect(unify(HeadSubLevelB, LevelB - 1),
+ $module, $pred, "HeadSubLevelB != LevelB - 1")
+ ),
+ find_interior_nodes_at_parent_offset(HeadSubLevelB,
+ HeadInteriorNodesB,
+ ParentLevelA, ParentInitOffsetA, ParentLimitOffsetA, NodesB)
+ )
+ ;
+ % ListA's range is after HeadB's range.
+ find_interior_nodes_at_parent_offset(LevelB, TailB,
+ ParentLevelA, ParentInitOffsetA, ParentLimitOffsetA, NodesB)
+ )
+ ;
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect(unify(ParentLevelA, LevelB), $module, $pred,
+ "ParentLevelA != LevelB")
+ ),
+ ( HeadB ^ init_offset > ParentInitOffsetA ->
+ % ListA's range is before HeadB's range.
+ % The nodes in ListA cover at most one level ParentLevelA span
+ % of bits. HeadB ^ init_offset should be a multiple of (a power of)
+ % that span, so if it is greater than the initial offset of a
+ % hypothetical level ParentLevelA interior node covering ListA's
+ % interior nodes, then it should be greater the final offset
+ % of that hypothetical node as well. The limit offset is one bigger
+ % than the final offset.
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ ( HeadB ^ init_offset >= ParentLimitOffsetA ->
+ true
+ ;
+ unexpected($module, $pred, "screwed-up offsets")
+ )
+ ),
+ NodesB = []
+ ; HeadB ^ init_offset = ParentInitOffsetA ->
+% NodesB = [HeadB]
+ ComponentsB = HeadB ^ components,
+ (
+ ComponentsB = leaf_list(_),
+ unexpected($module, $pred, "leaf_list")
+ ;
+ ComponentsB = interior_list(_, NodesB)
+ )
+ ;
+ find_interior_nodes_at_parent_offset(LevelB, TailB,
+ ParentLevelA, ParentInitOffsetA, ParentLimitOffsetA, NodesB)
+ )
+ ).
+
+:- pred descend_and_difference_one(int::in, list(interior_node)::in,
+ int::in, interior_node::in, int::out, list(interior_node)::out) is det.
+
+descend_and_difference_one(LevelA, InteriorNodesA, LevelB, InteriorNodeB,
+ Level, List) :-
+ ( LevelA > LevelB ->
+ (
+ InteriorNodesA = [],
+ Level = LevelA,
+ List = []
+ ;
+ InteriorNodesA = [HeadA | TailA],
+ ( HeadA ^ limit_offset =< InteriorNodeB ^ init_offset ->
+ % All of the region covered by HeadA is before the region
+ % covered by InteriorNodeB.
+ descend_and_difference_one(LevelA, TailA, LevelB, InteriorNodeB,
+ LevelTail, ListTail),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect(unify(LevelTail, LevelA),
+ $module, $pred, "LevelTail != LevelA")
+ ),
+ Level = LevelA,
+ List = [HeadA | ListTail]
+ ; HeadA ^ init_offset =< InteriorNodeB ^ init_offset ->
+ % The region covered by HeadA contains the region
+ % covered by InteriorNodeB.
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ ( InteriorNodeB ^ limit_offset =< HeadA ^ limit_offset ->
+ true
+ ;
+ unexpected($module, $pred, "weird region relationship")
+ )
+ ),
+ (
+ HeadA ^ components = leaf_list(_),
+ % LevelB is at least 1, LevelA is greater than LevelB,
+ % so stepping one level down from levelA should get us
+ % to at least level 1; level 0 cannot happen.
+ unexpected($module, $pred,
+ "HeadA ^ components is leaf_list")
+ ;
+ HeadA ^ components = interior_list(HeadASubLevel,
+ HeadASubNodes)
+ ),
+ descend_and_difference_one(HeadASubLevel, HeadASubNodes,
+ LevelB, InteriorNodeB, LevelSub, ListSub),
+ (
+ ListSub = [],
+ Level = LevelA,
+ List = TailA
+ ;
+ ListSub = [ListSubHead | ListSubTail],
+ raise_interiors_to_level(LevelA, LevelSub,
+ ListSubHead, ListSubTail, RaisedHead, RaisedTail),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect(unify(RaisedTail, []),
+ $module, $pred, "RaisedTail != []")
+ ),
+ Level = LevelA,
+ List = [RaisedHead | TailA]
+ )
+ ;
+ % All of the region covered by HeadA is after the region
+ % covered by InteriorNodeB, and therefore so are all the
+ % regions covered by TailA.
+ Level = LevelA,
+ List = InteriorNodesA
+ )
+ )
+ ; LevelA = LevelB ->
+ interiorlist_difference(InteriorNodesA, [InteriorNodeB], List),
+ Level = LevelA
+ ;
+ unexpected($module, $pred, "LevelA < LevelB")
+ ).
+
+:- pred descend_and_difference_list(int::in, list(interior_node)::in,
+ int::in, interior_node::in, list(interior_node)::in,
+ int::out, list(interior_node)::out) is det.
+
+descend_and_difference_list(LevelA, InteriorNodesA,
+ LevelB, InteriorNodeB, InteriorNodesB, Level, List) :-
+ ( LevelA > LevelB ->
+ (
+ InteriorNodesA = [],
+ Level = LevelA,
+ List = []
+ ;
+ InteriorNodesA = [HeadA | TailA],
+ ( HeadA ^ limit_offset =< InteriorNodeB ^ init_offset ->
+ % All of the region covered by HeadA is before the region
+ % covered by [InteriorNodeB | InteriorNodesB].
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ list.det_last([InteriorNodeB | InteriorNodesB], LastB),
+ expect((HeadA ^ limit_offset =< LastB ^ init_offset),
+ $module, $pred,
+ "HeadA ^ limit_offset > LastB ^ init_offset")
+ ),
+ descend_and_difference_list(LevelA, TailA,
+ LevelB, InteriorNodeB, InteriorNodesB,
+ LevelTail, ListTail),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect(unify(LevelTail, LevelA),
+ $module, $pred, "LevelTail != LevelA")
+ ),
+ Level = LevelA,
+ List = [HeadA | ListTail]
+ ; HeadA ^ init_offset =< InteriorNodeB ^ init_offset ->
+ % The region covered by HeadA contains the region
+ % covered by InteriorNodeB.
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ ( InteriorNodeB ^ limit_offset =< HeadA ^ limit_offset ->
+ true
+ ;
+ unexpected($module, $pred, "weird region relationship")
+ )
+ ),
+ (
+ HeadA ^ components = leaf_list(_),
+ % LevelB is at least 1, LevelA is greater than LevelB,
+ % so stepping one level down from levelA should get us
+ % to at least level 1; level 0 cannot happen.
+ unexpected($module, $pred,
+ "HeadA ^ components is leaf_list")
+ ;
+ HeadA ^ components = interior_list(HeadASubLevel,
+ HeadASubNodes)
+ ),
+ descend_and_difference_list(HeadASubLevel, HeadASubNodes,
+ LevelB, InteriorNodeB, InteriorNodesB, LevelSub, ListSub),
+ (
+ ListSub = [],
+ Level = LevelA,
+ List = TailA
+ ;
+ ListSub = [ListSubHead | ListSubTail],
+ raise_interiors_to_level(LevelA, LevelSub,
+ ListSubHead, ListSubTail, RaisedHead, RaisedTail),
+ trace [compile_time(flag("tree-bitset-checks"))] (
+ expect(unify(RaisedTail, []),
+ $module, $pred, "RaisedTail != []")
+ ),
+ Level = LevelA,
+ List = [RaisedHead | TailA]
+ )
+ ;
+ % All of the region covered by HeadA is after the region
+ % covered by InteriorNodeB, and therefore so are all the
+ % regions covered by TailA.
+ Level = LevelA,
+ List = InteriorNodesA
+ )
+ )
+ ; LevelA = LevelB ->
+ interiorlist_difference(InteriorNodesA,
+ [InteriorNodeB | InteriorNodesB], List),
+ Level = LevelA
+ ;
+ unexpected($module, $pred, "LevelA < LevelB")
+ ).
+
:- pred interiornode_difference(
int::in, interior_node::in, list(interior_node)::in,
int::in, interior_node::in, list(interior_node)::in,
cvs diff: Diffing mdbcomp
cvs diff: Diffing profiler
cvs diff: Diffing robdd
cvs diff: Diffing runtime
cvs diff: Diffing runtime/GETOPT
cvs diff: Diffing runtime/machdeps
cvs diff: Diffing samples
cvs diff: Diffing samples/appengine
cvs diff: Diffing samples/appengine/war
cvs diff: Diffing samples/appengine/war/WEB-INF
cvs diff: Diffing samples/c_interface
cvs diff: Diffing samples/c_interface/c_calls_mercury
cvs diff: Diffing samples/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/mercury_calls_c
cvs diff: Diffing samples/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/standalone_c
cvs diff: Diffing samples/concurrency
cvs diff: Diffing samples/concurrency/dining_philosophers
cvs diff: Diffing samples/concurrency/midimon
cvs diff: Diffing samples/diff
cvs diff: Diffing samples/java_interface
cvs diff: Diffing samples/java_interface/java_calls_mercury
cvs diff: Diffing samples/java_interface/mercury_calls_java
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
cvs diff: Diffing samples/solver_types
cvs diff: Diffing samples/tests
cvs diff: Diffing samples/tests/c_interface
cvs diff: Diffing samples/tests/c_interface/c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/tests/c_interface/mercury_calls_c
cvs diff: Diffing samples/tests/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/tests/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/tests/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/tests/diff
cvs diff: Diffing samples/tests/muz
cvs diff: Diffing samples/tests/rot13
cvs diff: Diffing samples/tests/solutions
cvs diff: Diffing samples/tests/toplevel
cvs diff: Diffing scripts
cvs diff: Diffing slice
cvs diff: Diffing ssdb
cvs diff: Diffing tests
cvs diff: Diffing tests/analysis
cvs diff: Diffing tests/analysis/ctgc
cvs diff: Diffing tests/analysis/excp
cvs diff: Diffing tests/analysis/ext
cvs diff: Diffing tests/analysis/sharing
cvs diff: Diffing tests/analysis/table
cvs diff: Diffing tests/analysis/trail
cvs diff: Diffing tests/analysis/unused_args
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/debugger/declarative
cvs diff: Diffing tests/dppd
cvs diff: Diffing tests/general
cvs diff: Diffing tests/general/accumulator
cvs diff: Diffing tests/general/string_format
cvs diff: Diffing tests/general/structure_reuse
cvs diff: Diffing tests/grade_subdirs
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/exceptions
cvs diff: Diffing tests/hard_coded/purity
cvs diff: Diffing tests/hard_coded/sub-modules
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/invalid/purity
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/mmc_make
cvs diff: Diffing tests/mmc_make/lib
cvs diff: Diffing tests/par_conj
cvs diff: Diffing tests/recompilation
cvs diff: Diffing tests/stm
cvs diff: Diffing tests/stm/orig
cvs diff: Diffing tests/stm/orig/stm-compiler
cvs diff: Diffing tests/stm/orig/stm-compiler/test1
cvs diff: Diffing tests/stm/orig/stm-compiler/test10
cvs diff: Diffing tests/stm/orig/stm-compiler/test2
cvs diff: Diffing tests/stm/orig/stm-compiler/test3
cvs diff: Diffing tests/stm/orig/stm-compiler/test4
cvs diff: Diffing tests/stm/orig/stm-compiler/test5
cvs diff: Diffing tests/stm/orig/stm-compiler/test6
cvs diff: Diffing tests/stm/orig/stm-compiler/test7
cvs diff: Diffing tests/stm/orig/stm-compiler/test8
cvs diff: Diffing tests/stm/orig/stm-compiler/test9
cvs diff: Diffing tests/stm/orig/stm-compiler-par
cvs diff: Diffing tests/stm/orig/stm-compiler-par/bm1
cvs diff: Diffing tests/stm/orig/stm-compiler-par/bm2
cvs diff: Diffing tests/stm/orig/stm-compiler-par/stmqueue
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test1
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test10
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test11
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test2
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test3
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test4
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test5
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test6
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test7
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test8
cvs diff: Diffing tests/stm/orig/stm-compiler-par/test9
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test1
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test2
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test3
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test4
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test5
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test6
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test7
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test8
cvs diff: Diffing tests/stm/orig/stm-compiler-par-asm_fast/test9
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/trailing
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
cvs diff: Diffing vim
cvs diff: Diffing vim/after
cvs diff: Diffing vim/ftplugin
cvs diff: Diffing vim/syntax
--------------------------------------------------------------------------
mercury-reviews mailing list
Post messages to: mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions: mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------
More information about the reviews
mailing list