[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