[m-rev.] diff: assertions in tree_bitset.m

Zoltan Somogyi zs at csse.unimelb.edu.au
Mon Aug 1 17:08:55 AEST 2011
Previous message: [m-rev.] for review: separate gcc and clang specific code in the runtime
Next message: [m-rev.] diff: bug fixes and improvements for string switches
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
library/tree_bitset.m:
	Put all the assertions into trace goals that can be switched on or off
	at will.

	If the assertions are disabled, we get a speedup of more than 7%
	on tools/speedtest.

library/Mercury.options:
	Given the recently discovered bugs in the tree_bitset module,
	enable the assertions for now.

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/Mercury.options
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/Mercury.options,v
retrieving revision 1.37
diff -u -b -r1.37 Mercury.options
--- library/Mercury.options	10 May 2011 04:12:27 -0000	1.37
+++ library/Mercury.options	1 Aug 2011 05:04:10 -0000
@@ -17,8 +17,10 @@
 MCFLAGS-set_ordlist += $(TYPE_SPEC_FLAGS)
 
 MCFLAGS-lexer += --optimize-constructor-last-call
+
 MCFLAGS-sparse_bitset += --use-atomic-cells --optimize-constant-propagation
-MCFLAGS-tree_bitset += --use-atomic-cells --optimize-constant-propagation
+MCFLAGS-tree_bitset += --use-atomic-cells --optimize-constant-propagation \
+	--trace-flag tree-bitset-checks
 
 # Speed up structure sharing analysis.
 MCFLAGS-set_ctree234 += --structure-sharing-widening 1
Index: library/tree_bitset.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/tree_bitset.m,v
retrieving revision 1.12
diff -u -b -r1.12 tree_bitset.m
--- library/tree_bitset.m	28 Jul 2011 04:52:50 -0000	1.12
+++ library/tree_bitset.m	1 Aug 2011 04:53:50 -0000
@@ -527,11 +527,10 @@
 :- func enum_to_index(T) = int <= enum(T).
 
 enum_to_index(Elem) = Index :-
-    Int = enum.to_int(Elem),
-    ( Int < 0 ->
-        unexpected($module, $pred, "enums must map to nonnegative integers")
-    ;
-        Index = Int
+    Index = enum.to_int(Elem),
+    trace [compile_time(flag("tree-bitset-checks"))] (
+        expect((Index >= 0), $module, $pred,
+            "enums must map to nonnegative integers")
     ).
 
 :- func index_to_enum(int) = T <= enum(T).
@@ -829,8 +828,10 @@
     range_of_parent_node(HeadB ^ init_offset, CurLevel,
         ParentInitOffsetB, ParentLimitOffsetB),
     ( ParentInitOffsetA = ParentInitOffsetB ->
+        trace [compile_time(flag("tree-bitset-checks"))] (
         expect(unify(ParentLimitOffsetA, ParentLimitOffsetB),
-            $module, $pred, "limit mismatch"),
+                $module, $pred, "limit mismatch")
+        ),
         TopHeadA = HeadA,
         TopTailA = TailA,
         TopHeadB = HeadB,
@@ -1047,14 +1048,18 @@
         Components0 = Head0 ^ components,
         (
             Components0 = leaf_list(LeafList0),
+            trace [compile_time(flag("tree-bitset-checks"))] (
             expect(unify(Level, 1), $module, $pred,
-                "bad component list (leaf)"),
+                    "bad component list (leaf)")
+            ),
             leaflist_insert(Index, LeafList0, LeafList),
             Components = leaf_list(LeafList)
         ;
             Components0 = interior_list(InteriorLevel, InteriorList0),
+            trace [compile_time(flag("tree-bitset-checks"))] (
             expect(unify(InteriorLevel, Level - 1), $module, $pred,
-                "bad component list (interior)"),
+                    "bad component list (interior)")
+            ),
             interiorlist_insert(Index, InteriorLevel,
                 InteriorList0, InteriorList),
             Components = interior_list(InteriorLevel, InteriorList)
@@ -1428,8 +1433,10 @@
     range_of_parent_node(Head ^ leaf_offset, 0,
         HeadParentInitOffset, HeadParentLimitOffset),
     ( ParentInitOffset = HeadParentInitOffset ->
+        trace [compile_time(flag("tree-bitset-checks"))] (
         expect(unify(ParentLimitOffset, HeadParentLimitOffset),
-            $module, $pred, "limit mismatch"),
+                $module, $pred, "limit mismatch")
+        ),
         !:RevAcc = [Head | !.RevAcc],
         group_leaf_nodes_in_range(ParentInitOffset, ParentLimitOffset,
             !.RevAcc, Tail, ParentNode, Remaining)
@@ -1489,8 +1496,10 @@
     range_of_parent_node(Head ^ init_offset, Level,
         HeadParentInitOffset, HeadParentLimitOffset),
     ( ParentInitOffset = HeadParentInitOffset ->
+        trace [compile_time(flag("tree-bitset-checks"))] (
         expect(unify(ParentLimitOffset, HeadParentLimitOffset),
-            $module, $pred, "limit mismatch"),
+                $module, $pred, "limit mismatch")
+        ),
         !:RevAcc = [Head | !.RevAcc],
         group_interior_nodes_in_range(Level,
             ParentInitOffset, ParentLimitOffset,
@@ -1665,8 +1674,10 @@
             range_of_parent_node(FirstNodeB ^ leaf_offset, 0,
                 ParentInitOffsetB, ParentLimitOffsetB),
             ( ParentInitOffsetA = ParentInitOffsetB ->
+                trace [compile_time(flag("tree-bitset-checks"))] (
                 expect(unify(ParentLimitOffsetA, ParentLimitOffsetB),
-                    $module, $pred, "limit mismatch"),
+                        $module, $pred, "limit mismatch")
+                ),
                 leaflist_union(LeafNodesA, LeafNodesB, LeafNodes),
                 List = leaf_list(LeafNodes)
             ;
@@ -1787,8 +1798,10 @@
         ;
             ComponentsA = interior_list(LevelA, InteriorListA),
             ComponentsB = interior_list(LevelB, InteriorListB),
+            trace [compile_time(flag("tree-bitset-checks"))] (
             expect(unify(LevelA, LevelB), $module, $pred,
-                "inconsistent levels"),
+                    "inconsistent levels")
+            ),
             interiorlist_union(InteriorListA, InteriorListB, InteriorList),
             Components = interior_list(LevelA, InteriorList),
             Head = interior_node(HeadA ^ init_offset, HeadA ^ limit_offset,
@@ -1832,8 +1845,10 @@
             range_of_parent_node(FirstNodeB ^ leaf_offset, 0,
                 ParentInitOffsetB, ParentLimitOffsetB),
             ( ParentInitOffsetA = ParentInitOffsetB ->
+                trace [compile_time(flag("tree-bitset-checks"))] (
                 expect(unify(ParentLimitOffsetA, ParentLimitOffsetB),
-                    $module, $pred, "limit mismatch"),
+                        $module, $pred, "limit mismatch")
+                ),
                 leaflist_intersect(LeafNodesA, LeafNodesB, LeafNodes),
                 List = leaf_list(LeafNodes)
             ;
@@ -1922,10 +1937,14 @@
         InteriorNodeA ^ limit_offset =< HeadB ^ limit_offset
     ->
         ( LevelA = LevelB ->
-            expect(unify(InteriorNodeA ^ init_offset, HeadB ^ init_offset),
+            trace [compile_time(flag("tree-bitset-checks"))] (
+                expect(
+                    unify(InteriorNodeA ^ init_offset, HeadB ^ init_offset),
                 $module, $pred, "inconsistent inits"),
-            expect(unify(InteriorNodeA ^ limit_offset, HeadB ^ limit_offset),
-                $module, $pred, "inconsistent limits"),
+                expect(
+                    unify(InteriorNodeA ^ limit_offset, HeadB ^ limit_offset),
+                    $module, $pred, "inconsistent limits")
+            ),
             ComponentsA = InteriorNodeA ^ components,
             ComponentsB = HeadB ^ components,
             (
@@ -1936,13 +1955,11 @@
             ;
                 ComponentsA = leaf_list(_),
                 ComponentsB = interior_list(_, _),
-                unexpected($module, $pred,
-                    "inconsistent levels")
+                unexpected($module, $pred, "inconsistent levels")
             ;
                 ComponentsA = interior_list(_, _),
                 ComponentsB = leaf_list(_),
-                unexpected($module, $pred,
-                    "inconsistent levels")
+                unexpected($module, $pred, "inconsistent levels")
             ;
                 ComponentsA = interior_list(_SubLevelA, InteriorNodesA),
                 ComponentsB = interior_list(_SubLevelB, InteriorNodesB),
@@ -1951,7 +1968,9 @@
                 List = interior_list(LevelA, InteriorNodes)
             )
         ;
-            expect(LevelA < LevelB, $module, $pred, "LevelA > LevelB"),
+            trace [compile_time(flag("tree-bitset-checks"))] (
+                expect(LevelA < LevelB, $module, $pred, "LevelA > LevelB")
+            ),
             ComponentsB = HeadB ^ components,
             (
                 ComponentsB = leaf_list(_),
@@ -2023,8 +2042,10 @@
         ;
             ComponentsA = interior_list(LevelA, InteriorNodesA),
             ComponentsB = interior_list(LevelB, InteriorNodesB),
+            trace [compile_time(flag("tree-bitset-checks"))] (
             expect(unify(LevelA, LevelB), $module, $pred,
-                "inconsistent levels"),
+                    "inconsistent levels")
+            ),
             interiorlist_intersect(InteriorNodesA, InteriorNodesB,
                 InteriorNodes),
             (
@@ -2073,8 +2094,10 @@
             range_of_parent_node(FirstNodeB ^ leaf_offset, 0,
                 ParentInitOffsetB, ParentLimitOffsetB),
             ( ParentInitOffsetA = ParentInitOffsetB ->
+                trace [compile_time(flag("tree-bitset-checks"))] (
                 expect(unify(ParentLimitOffsetA, ParentLimitOffsetB),
-                    $module, $pred, "limit mismatch"),
+                        $module, $pred, "limit mismatch")
+                ),
                 leaflist_difference(LeafNodesA, LeafNodesB, LeafNodes),
                 List = leaf_list(LeafNodes)
             ;
@@ -2139,13 +2162,17 @@
             ComponentsB = ChosenB ^ components,
             (
                 ComponentsB = leaf_list(_),
-                expect(unify(LevelA, 1), $module, $pred, "bad leaf level"),
+                trace [compile_time(flag("tree-bitset-checks"))] (
+                    expect(unify(LevelA, 1), $module, $pred, "bad leaf level")
+                ),
                 interiorlist_difference([HeadA | TailA], [ChosenB], List),
                 Level = LevelA
             ;
                 ComponentsB = interior_list(SubLevelB, SubNodesB),
+                trace [compile_time(flag("tree-bitset-checks"))] (
                 expect(unify(LevelB, SubLevelB + 1), $module, $pred,
-                    "bad levels"),
+                        "bad levels")
+                ),
                 head_and_tail(SubNodesB, SubHeadB, SubTailB),
                 interiornode_difference(LevelA, HeadA, TailA,
                     SubLevelB, SubHeadB, SubTailB, Level, List)
@@ -2162,8 +2189,10 @@
         range_of_parent_node(RaisedHeadB ^ init_offset, LevelA,
             ParentInitOffsetB, ParentLimitOffsetB),
         ( ParentInitOffsetA = ParentInitOffsetB ->
+            trace [compile_time(flag("tree-bitset-checks"))] (
             expect(unify(ParentLimitOffsetA, ParentLimitOffsetB),
-                $module, $pred, "limit mismatch"),
+                    $module, $pred, "limit mismatch")
+            ),
             interiorlist_difference([HeadA | TailA],
                 [RaisedHeadB | RaisedTailB], List),
             Level = LevelA
@@ -2259,8 +2288,10 @@
         ;
             ComponentsA = interior_list(LevelA, InteriorNodesA),
             ComponentsB = interior_list(LevelB, InteriorNodesB),
+            trace [compile_time(flag("tree-bitset-checks"))] (
             expect(unify(LevelA, LevelB), $module, $pred,
-                "inconsistent levels"),
+                    "inconsistent levels")
+            ),
             interiorlist_difference(InteriorNodesA, InteriorNodesB,
                 InteriorNodes),
             (
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
--------------------------------------------------------------------------
Previous message: [m-rev.] for review: separate gcc and clang specific code in the runtime
Next message: [m-rev.] diff: bug fixes and improvements for string switches
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the reviews mailing list