[m-rev.] diff: towards tail recursion in loop control

Zoltan Somogyi zs at csse.unimelb.edu.au
Thu Oct 20 14:34:29 AEDT 2011


compiler/par_loop_control.m:
	Add draft support for copying shared variables to child stacks
	in order to enable tail recursion.

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
Index: compiler/code_gen.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/code_gen.m,v
retrieving revision 1.188
diff -u -b -r1.188 code_gen.m
--- compiler/code_gen.m	19 Oct 2011 01:08:28 -0000	1.188
+++ compiler/code_gen.m	19 Oct 2011 15:58:20 -0000
@@ -267,7 +267,7 @@
             unify_gen.generate_ground_term(TermVar, SubGoal, !CI),
             Code = empty
         ; Reason = loop_control(LCVar, LCSVar, UseParentStack) ->
-            par_conj_gen.generate_loop_control(SubGoal, LCVar, LCSVar,
+            par_conj_gen.generate_lc_spawn_off(SubGoal, LCVar, LCSVar,
                 UseParentStack, Code, !CI)
         ;
             commit_gen.generate_scope(Reason, CodeModel, GoalInfo,
Index: compiler/llds_out_data.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/llds_out_data.m,v
retrieving revision 1.7
diff -u -b -r1.7 llds_out_data.m
--- compiler/llds_out_data.m	17 Oct 2011 04:31:29 -0000	1.7
+++ compiler/llds_out_data.m	19 Oct 2011 16:53:35 -0000
@@ -588,7 +588,7 @@
     io.write_string("MR_Code *", !IO).
 
 lval_to_string(reg(RegType, RegNum)) =
-    "reg(" ++ reg_to_string(RegType, RegNum) ++ ")".
+    reg_to_string(RegType, RegNum).
 lval_to_string(framevar(N)) =
     "MR_fv(" ++ int_to_string(N) ++ ")".
 lval_to_string(stackvar(N)) =
Index: compiler/par_conj_gen.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/par_conj_gen.m,v
retrieving revision 1.50
diff -u -b -r1.50 par_conj_gen.m
--- compiler/par_conj_gen.m	19 Oct 2011 01:08:29 -0000	1.50
+++ compiler/par_conj_gen.m	19 Oct 2011 16:54:46 -0000
@@ -100,7 +100,7 @@
 :- pred generate_par_conj(list(hlds_goal)::in, hlds_goal_info::in,
     code_model::in, llds_code::out, code_info::in, code_info::out) is det.
 
-:- pred generate_loop_control(hlds_goal::in, prog_var::in, prog_var::in,
+:- pred generate_lc_spawn_off(hlds_goal::in, prog_var::in, prog_var::in,
     lc_use_parent_stack::in, llds_code::out, code_info::in, code_info::out)
     is det.
 
@@ -121,6 +121,8 @@
 :- import_module ll_backend.code_info.
 :- import_module ll_backend.continuation_info.
 :- import_module ll_backend.exprn_aux.
+:- import_module ll_backend.llds_out.
+:- import_module ll_backend.llds_out.llds_out_data.
 :- import_module ll_backend.var_locn.
 :- import_module mdbcomp.goal_path.
 :- import_module parse_tree.set_of_var.
@@ -329,47 +331,91 @@
 
 %-----------------------------------------------------------------------------%
 
-generate_loop_control(Goal, LCVar, LCSVar, UseParentStack, Code, !CI) :-
+generate_lc_spawn_off(Goal, LCVar, LCSVar, UseParentStack, Code, !CI) :-
     % We don't need to save the parent stack pointer, we do not use it in the
     % main context and all the worker contexts will never have some data that
     % we shouldn't clobber there.
     % We also expect the runtime code to setup the parent stack pointer for us.
 
+    get_known_variables(!.CI, KnownVars),
+    KnownVarsSet = set_of_var.list_to_set(KnownVars),
+    NonLocalsSet = goal_info_get_nonlocals(Goal ^ hlds_goal_info),
+    InputVarsSet = set_of_var.intersect(NonLocalsSet, KnownVarsSet),
+    InputVars = set_of_var.to_sorted_list(InputVarsSet),
+    save_variables_on_stack(InputVars, SaveCode, !CI),
+
+    best_variable_location_det(!.CI, LCVar, LCVarLocn),
+    best_variable_location_det(!.CI, LCSVar, LCSVarLocn),
+
     (
         UseParentStack = lc_use_parent_stack_frame,
-        get_known_variables(!.CI, KnownVars),
-        NonLocals = goal_info_get_nonlocals(Goal ^ hlds_goal_info),
-        InputVars = set_of_var.intersect(NonLocals, list_to_set(KnownVars)),
-        save_variables_on_stack(to_sorted_list(InputVars), SaveCode, !CI)
+        CopyCode = cord.empty
     ;
         UseParentStack = lc_create_frame_on_child_stack,
-        % XXX: Allocate a frame on the child's stack.
-        % Copy the variables to the child's stack.
-        % I'll (Paul) provide C macros in the runtime system for these actions.
-        sorry($module, $pred, "unimplemented")
+        list.map(get_variable_slot(!.CI), InputVars, InputStackSlots),
+
+        % XXX We only know the size of the stack frame for certain
+        % after we have finished generating code for the procedure.
+        %
+        % There are several different ways we can set the size of the first
+        % stack frame on the stack of the child context.
+        %
+        % The simplest way is to make a hopefully conservative estimate of the
+        % size of the current procedure's stack frame. If necessary, we can
+        % ENSURE that this estimate is conservative by testing whether it is at
+        % the end of generate_proc_code, and if not, recording the actual stack
+        % frame size in the code_info and redoing the code generation for the
+        % entire procedure, this time using the recorded size instead of the
+        % estimate.
+        %
+        % A second way is to move this code AFTER we have computed GoalCode,
+        % collect all the stackvar references in it, and base the size of the
+        % child stack frame on the highest numbered stackvar reference in
+        % there.
+        %
+        % The third way is the same as the second, except it compresses
+        % out any stack slots that are not used by GoalCode. This would require
+        % remapping all the stackvar references in GoalCode, as well as
+        % applying the compression map during the creation of CopyStr.
+        %
+        % For now, we use the first method without the fallback. This should
+        % be sufficient for the correctness of our benchmark programs, and
+        % *shouldn't* lose too much efficiency.
+
+        FrameSize = 100,
+        copy_slots_to_child_stack(FrameSize, LCVarLocn, LCSVarLocn,
+            InputStackSlots, CopyStr),
+        AffectsLiveness = proc_does_not_affect_liveness,
+        LiveLvalsInfo = live_lvals_info(
+            set.list_to_set([LCVarLocn, LCSVarLocn | InputStackSlots])),
+        CopyUinstr = arbitrary_c_code(AffectsLiveness, LiveLvalsInfo,
+            CopyStr),
+        CopyInstr = llds_instr(CopyUinstr, ""),
+        CopyCode = singleton(CopyInstr)
     ),
 
     % Create the call to spawn_off.
     remember_position(!.CI, PositionBeforeSpawnOff),
 
     get_next_label(SpawnOffLabel, !CI),
-    best_variable_location_det(!.CI, LCVar, LCVarLocn),
-    best_variable_location_det(!.CI, LCSVar, LCSVarLocn),
-    SpawnOffCallCode =
-        singleton(llds_instr(lc_spawn_off(lval(LCVarLocn), lval(LCSVarLocn),
+    SpawnUinstr = lc_spawn_off(lval(LCVarLocn), lval(LCSVarLocn),
                 SpawnOffLabel),
-            "Spawn off job for worker using loop control")),
-    SpawnOffCode = SpawnOffCallCode,
+    SpawnInstr = llds_instr(SpawnUinstr, ""),
+    SpawnOffCode = singleton(SpawnInstr),
+    % XXX This snapshot seems unnecessary; it is guaranteed to be the same
+    % as the previous snapshot.
     remember_position(!.CI, PositionAfterSpawnOff),
 
     % Code to spawn off.
-    LabelCode = singleton(llds_instr(label(SpawnOffLabel),
-        "Label for spawned off code")),
+    LabelUinstr = label(SpawnOffLabel),
+    LabelInstr = llds_instr(LabelUinstr, "Label for spawned off code"),
+    LabelCode = singleton(LabelInstr),
+    % XXX This reset seems unnecessary; no code
     reset_to_position(PositionBeforeSpawnOff, !CI),
 
     % We don't need to clear all the registers, all the variables except for
     % LC and LCS are considered to be on the stack.
-    % mark only the registers used by LC and LCS as clobbered.
+    % Mark only the registers used by LC and LCS as clobbered.
     clobber_regs([LCVarLocn, LCSVarLocn], !CI),
 
     generate_goal(model_det, Goal, GoalCode, !CI),
@@ -379,24 +425,62 @@
     (
         UseParentStack = lc_use_parent_stack_frame,
         replace_stack_vars_by_parent_sv(SpawnedOffCode0, SpawnedOffCode)
+    ;
+        UseParentStack = lc_create_frame_on_child_stack,
+        SpawnedOffCode = SpawnedOffCode0
 
-% XXX: Comment back in this case after addressing the one above.  The compiler
-% won't let me include this case if the one above is erroneous.
-%    ;
-%        UseParentStack = lc_create_frame_on_child_stack,
-%
-%        % XXX: We could take this opportunity to remove gaps in the stack
-%        % frame as discussed in our meetings.
-%        sorry($module, $pred, "unimplemented")
+        % XXX: We could take this opportunity to remove gaps in the stack
+        % frame as discussed in our meetings.
+        % sorry($module, $pred, "unimplemented")
     ),
 
     reset_to_position(PositionAfterSpawnOff, !CI),
 
-    % The spawned off code is written into the procedure seperatly.
+    % The spawned off code is written into the procedure separately.
     add_out_of_line_code(SpawnedOffCode, !CI),
 
-    % Concatentate the inline code.
-    Code = SaveCode ++ SpawnOffCode.
+    % Concatenate the inline code.
+    Code = SaveCode ++ CopyCode ++ SpawnOffCode.
+
+:- pred copy_slots_to_child_stack(int::in, lval::in, lval::in, list(lval)::in,
+    string::out) is det.
+
+copy_slots_to_child_stack(FrameSize, LCVarLocn, LCSVarLocn, StackSlots,
+        CodeStr) :-
+    (
+        LCVarNamePrime = lval_to_string(LCVarLocn),
+        LCSVarNamePrime = lval_to_string(LCSVarLocn)
+    ->
+        LCVarName = LCVarNamePrime,
+        LCSVarName = LCSVarNamePrime
+    ;
+        unexpected($module, $pred, "cannot convert to string")
+    ),
+
+    BaseVarName = "BaseSp",
+    FirstLine = "{\n",
+    DeclLine = string.format("\tMR_Word *%s;\n", [s(BaseVarName)]),
+    AssignLine = string.format("\t%s = MR_lc_child_stack_sp(%s, %s, %d);\n",
+        [s(BaseVarName), s(LCVarName), s(LCSVarName), i(FrameSize)]),
+    list.map(copy_one_slot_to_child_stack(BaseVarName),
+        StackSlots, CopyStrs),
+    string.append_list(CopyStrs, CopyLines),
+    LastLine = "\t}\n",
+    CodeStr = FirstLine ++ DeclLine ++ AssignLine ++ CopyLines ++ LastLine.
+
+:- pred copy_one_slot_to_child_stack(string::in, lval::in, string::out) is det.
+
+copy_one_slot_to_child_stack(BaseVarName, StackSlot, CopyStr) :-
+    ( StackSlotName = lval_to_string(StackSlot) ->
+        ( StackSlot = stackvar(N) ->
+            CopyStr = string.format("\tMR_based_stackvar(%s, %d) = %s;\n",
+                [s(BaseVarName), i(N), s(StackSlotName)])
+        ;
+            unexpected($module, $pred, "not stack slot")
+        )
+    ;
+        unexpected($module, $pred, "cannot convert to string")
+    ).
 
 %----------------------------------------------------------------------------%
 
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
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/lazy_list
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
Index: tests/par_conj/rr.exp
===================================================================
RCS file: tests/par_conj/rr.exp
diff -N tests/par_conj/rr.exp
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ tests/par_conj/rr.exp	20 Oct 2011 00:37:35 -0000
@@ -0,0 +1 @@
+9
Index: tests/par_conj/rr.m
===================================================================
RCS file: tests/par_conj/rr.m
diff -N tests/par_conj/rr.m
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ tests/par_conj/rr.m	20 Oct 2011 00:36:55 -0000
@@ -0,0 +1,34 @@
+% vim: ts=4 sw=4 ts ft=mercury
+%
+% Test case to test the par_loop_control.m's handling of right recursion.
+% The code is a simplified version of map_foldl.
+
+:- module rr.
+
+:- interface.
+
+:- import_module io.
+
+:- pred main(io::di, io::uo) is det.
+
+:- implementation.
+
+:- import_module int.
+:- import_module list.
+
+main(!IO) :-
+    mf([1, 2, 3], 0, Result),
+    io.write_int(Result, !IO),
+    nl(!IO).
+
+:- pred mf(list(int)::in, int::in, int::out) is det.
+
+mf([], !Acc).
+mf([X | Xs], !Acc) :-
+	(
+		Y = X + 1,
+		!:Acc = !.Acc + Y
+	&
+		mf(Xs, !Acc)
+	).
+
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