[m-rev.] for review: generalize the specialization of compare/3 predicates

Zoltan Somogyi zs at cs.mu.OZ.AU
Mon Jan 21 18:12:07 AEDT 2002
Previous message: [m-rev.] For review: state variable syntax (long diff)
Next message: [m-rev.] for review: generalize the specialization of compare/3 predicates
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
For anyone to review.

We have two ways to generate comparison predicates for du types. Suppose the
type has n function symbols. The quadratic method has n^2 clauses, one for each
combination of the bindings of the two arguments. The linear method creates an
index predicate for the type, calls it on each argument, and returns
immediately if the index values indicate a difference. If the index values
say the two arguments are bound to the same function symbol, the linear method
then has n cases, each comparing the arguments of a function symbol.

The quadratic method can be expected to be faster since it avoids function
calls and does fewer tests on the function symbol bound to each argument.
For small values of n, it can also be smaller, mainly due to the absence
of the index predicate. This change allows the user to select the use of
the quadratic method for all types whose value of n is up to a given limit,
whereas before there was a hardcoded limit on the limit, requiring n <= 3.

My benchmark results so far show that we should be using the quadratic method
for all n <= 9, but I do not have benchmark results yet for n >= 10. When I do,
I will modify the default value of --compare-specialization, the option
that gives the limit up to which we use the quadratic method.

compiler/unify_proc.m:
	Generalize the code that generates comparison procedures that
	explicitly compare each function symbol with every other, to
	handle types with any number of function symbols. Rename some
	predicates to make clearer the distinction between these predicates,
	which generate comparison predicates whose size is quadratic in the
	the number of function symbols in the type, from the predicates
	which generate comparison predicates whose size is linear in the
	the number of function symbols in the type.

compiler/handle_options.m:
	Delete the code that limited the exploited value of the
	--compare-specialization option, since the change to unify_proc.m
	has removed the cause of the limitation.

The benchmark results show mostly timing noise until --compare-specialization
reaches 9; it seems a frequently compared type has that arity. I don't know
which type that is.

EXTRA_MCFLAGS = -O2 --compare-specialization 0
GRADE = asm_fast.gc
mercury_compile.01 average of 8 with ignore=0     17.72
mercury_compile.01 average of 8 with ignore=1     17.58
mercury_compile.01 average of 8 with ignore=2     17.57
EXTRA_MCFLAGS = -O2 --compare-specialization 1
GRADE = asm_fast.gc
mercury_compile.02 average of 8 with ignore=0     17.82
mercury_compile.02 average of 8 with ignore=1     17.62
mercury_compile.02 average of 8 with ignore=2     17.62
EXTRA_MCFLAGS = -O2 --compare-specialization 2
GRADE = asm_fast.gc
mercury_compile.03 average of 8 with ignore=0     17.67
mercury_compile.03 average of 8 with ignore=1     17.43
mercury_compile.03 average of 8 with ignore=2     17.43
EXTRA_MCFLAGS = -O2 --compare-specialization 3
GRADE = asm_fast.gc
mercury_compile.04 average of 8 with ignore=0     17.70
mercury_compile.04 average of 8 with ignore=1     17.48
mercury_compile.04 average of 8 with ignore=2     17.48
EXTRA_MCFLAGS = -O2 --compare-specialization 4
GRADE = asm_fast.gc
mercury_compile.05 average of 8 with ignore=0     17.80
mercury_compile.05 average of 8 with ignore=1     17.59
mercury_compile.05 average of 8 with ignore=2     17.59
EXTRA_MCFLAGS = -O2 --compare-specialization 5
GRADE = asm_fast.gc
mercury_compile.06 average of 8 with ignore=0     17.72
mercury_compile.06 average of 8 with ignore=1     17.50
mercury_compile.06 average of 8 with ignore=2     17.50
EXTRA_MCFLAGS = -O2 --compare-specialization 6
GRADE = asm_fast.gc
mercury_compile.07 average of 8 with ignore=0     17.76
mercury_compile.07 average of 8 with ignore=1     17.52
mercury_compile.07 average of 8 with ignore=2     17.51
EXTRA_MCFLAGS = -O2 --compare-specialization 7
GRADE = asm_fast.gc
mercury_compile.08 average of 8 with ignore=0     17.80
mercury_compile.08 average of 8 with ignore=1     17.58
mercury_compile.08 average of 8 with ignore=2     17.58
EXTRA_MCFLAGS = -O2 --compare-specialization 8
GRADE = asm_fast.gc
mercury_compile.09 average of 8 with ignore=0     17.79
mercury_compile.09 average of 8 with ignore=1     17.58
mercury_compile.09 average of 8 with ignore=2     17.58
EXTRA_MCFLAGS = -O2 --compare-specialization 9
GRADE = asm_fast.gc
mercury_compile.10 average of 8 with ignore=0     17.53
mercury_compile.10 average of 8 with ignore=1     17.30
mercury_compile.10 average of 8 with ignore=2     17.30
EXTRA_MCFLAGS = -O2 --compare-specialization 0
GRADE = hlc.gc
mercury_compile.11 average of 8 with ignore=0     21.43
mercury_compile.11 average of 8 with ignore=1     21.25
mercury_compile.11 average of 8 with ignore=2     21.25
EXTRA_MCFLAGS = -O2 --compare-specialization 1
GRADE = hlc.gc
mercury_compile.12 average of 8 with ignore=0     21.45
mercury_compile.12 average of 8 with ignore=1     21.28
mercury_compile.12 average of 8 with ignore=2     21.28
EXTRA_MCFLAGS = -O2 --compare-specialization 2
GRADE = hlc.gc
mercury_compile.13 average of 8 with ignore=0     21.46
mercury_compile.13 average of 8 with ignore=1     21.29
mercury_compile.13 average of 8 with ignore=2     21.29
EXTRA_MCFLAGS = -O2 --compare-specialization 3
GRADE = hlc.gc
mercury_compile.14 average of 8 with ignore=0     21.32
mercury_compile.14 average of 8 with ignore=1     21.15
mercury_compile.14 average of 8 with ignore=2     21.15
EXTRA_MCFLAGS = -O2 --compare-specialization 4
GRADE = hlc.gc
mercury_compile.15 average of 8 with ignore=0     21.32
mercury_compile.15 average of 8 with ignore=1     21.15
mercury_compile.15 average of 8 with ignore=2     21.15
EXTRA_MCFLAGS = -O2 --compare-specialization 5
GRADE = hlc.gc
mercury_compile.16 average of 8 with ignore=0     21.37
mercury_compile.16 average of 8 with ignore=1     21.19
mercury_compile.16 average of 8 with ignore=2     21.18
EXTRA_MCFLAGS = -O2 --compare-specialization 6
GRADE = hlc.gc
mercury_compile.17 average of 8 with ignore=0     21.36
mercury_compile.17 average of 8 with ignore=1     21.19
mercury_compile.17 average of 8 with ignore=2     21.19
EXTRA_MCFLAGS = -O2 --compare-specialization 7
GRADE = hlc.gc
mercury_compile.18 average of 8 with ignore=0     21.39
mercury_compile.18 average of 8 with ignore=1     21.21
mercury_compile.18 average of 8 with ignore=2     21.20
EXTRA_MCFLAGS = -O2 --compare-specialization 8
GRADE = hlc.gc
mercury_compile.19 average of 8 with ignore=0     21.36
mercury_compile.19 average of 8 with ignore=1     21.18
mercury_compile.19 average of 8 with ignore=2     21.18
EXTRA_MCFLAGS = -O2 --compare-specialization 9
GRADE = hlc.gc
mercury_compile.20 average of 8 with ignore=0     21.16
mercury_compile.20 average of 8 with ignore=1     20.98
mercury_compile.20 average of 8 with ignore=2     20.97

Output of the size command. The first column is the interesting one, giving
executable code size. The versions are in the same order as above; the first
ten being asm_fast.gc, the last ten being hlc.gc. With asm_fast.gc, there is
a steady reduction in code size; with hlc.gc, the reduction reverses very
slightly as we go from --compare-specialization 7 to 8 to 9.

6378003	 102404	  70680	6551087	 63f62f	compspec.01
6357347	 102404	  70680	6530431	 63a57f	compspec.02
6339443	 102404	  70680	6512527	 635f8f	compspec.03
6327283	 102404	  70680	6500367	 63300f	compspec.04
6320931	 103332	  70680	6494943	 631adf	compspec.05
6318627	 104004	  70680	6493311	 63147f	compspec.06
6318035	 104420	  70680	6493135	 6313cf	compspec.07
6317491	 105028	  70680	6493199	 63140f	compspec.08
6316131	 106052	  70680	6492863	 6312bf	compspec.09
6312883	 108452	  70680	6492015	 630f6f	compspec.10
4387462	   3864	  70776	4462102	 441616	compspec.11
4381190	   3864	  70776	4455830	 43fd96	compspec.12
4370246	   3864	  70776	4444886	 43d2d6	compspec.13
4363206	   3864	  70776	4437846	 43b756	compspec.14
4360630	   3864	  70776	4435270	 43ad46	compspec.15
4359318	   3864	  70776	4433958	 43a826	compspec.16
4359014	   3864	  70776	4433654	 43a6f6	compspec.17
4358726	   3864	  70776	4433366	 43a5d6	compspec.18
4359142	   3864	  70776	4433782	 43a776	compspec.19
4360022	   3864	  70776	4434662	 43aae6	compspec.20

Zoltan.

cvs diff: Diffing .
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/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/handle_options.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/handle_options.m,v
retrieving revision 1.125
diff -u -b -r1.125 handle_options.m
--- compiler/handle_options.m	2002/01/11 07:44:29	1.125
+++ compiler/handle_options.m	2002/01/20 03:30:04
@@ -460,15 +460,6 @@
 	% --split-c-files implies --procs-per-c-function 1
 	option_implies(split_c_files, procs_per_c_function, int(1)),
 
-	% make_hlds contains an optimization which requires the value of the
-	% compare_specialization option to accurately specify the max number
-	% of constructors in a type whose comparison procedure is specialized
-	% and which therefore don't need index functions.
-	globals__io_lookup_int_option(compare_specialization, CompareSpec0),
-	{ int__min(unify_proc__max_exploited_compare_spec_value,
-		CompareSpec0, CompareSpec) },
-	globals__io_set_option(compare_specialization, int(CompareSpec)),
-
 	% Minimal model tabling is not compatible with trailing;
 	% see the comment in runtime/mercury_tabling.c.
 
Index: compiler/unify_proc.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/unify_proc.m,v
retrieving revision 1.100
diff -u -b -r1.100 unify_proc.m
--- compiler/unify_proc.m	2002/01/18 04:00:50	1.100
+++ compiler/unify_proc.m	2002/01/20 03:29:00
@@ -117,12 +117,6 @@
 	hlds_type_body::in, prog_context::in, module_info::in,
 	clauses_info::out) is det.
 
-	% This number gives the maximum number of constructors in a type
-	% whose compare procedure can be specialized, and whose compare
-	% procedure therefore does need an index procedure on that type.
-
-:- func unify_proc__max_exploited_compare_spec_value = int.
-
 %-----------------------------------------------------------------------------%
 %-----------------------------------------------------------------------------%
 
@@ -1069,52 +1063,32 @@
 				Ctor, Res, H1, H2,
 				Context, Clauses)
 		;
-			unify_proc__generate_du_general_compare_clauses(Type,
+			unify_proc__generate_du_linear_compare_clauses(Type,
 				Ctors, Res, H1, H2, Context, Clauses)
 		)
 	;
-		{ Ctors = [Ctor1, Ctor2] },
+		{ Ctors = [_, _ | _] },
 		unify_proc__info_get_module_info(ModuleInfo),
 		{ module_info_globals(ModuleInfo, Globals) },
 		{ globals__lookup_int_option(Globals, compare_specialization,
 			CompareSpec) },
-		( { CompareSpec >= 2 } ->
-			unify_proc__generate_du_two_compare_clauses(
-				Ctor1, Ctor2, Res, H1, H2,
-				Context, Clauses)
-		;
-			unify_proc__generate_du_general_compare_clauses(Type,
+		{ list__length(Ctors, NumCtors) },
+		( { CompareSpec >= NumCtors } ->
+			unify_proc__generate_du_quad_compare_clauses(
 				Ctors, Res, H1, H2, Context, Clauses)
-		)
-	;
-		{ Ctors = [Ctor1, Ctor2, Ctor3] },
-		unify_proc__info_get_module_info(ModuleInfo),
-		{ module_info_globals(ModuleInfo, Globals) },
-		{ globals__lookup_int_option(Globals, compare_specialization,
-			CompareSpec) },
-		( { CompareSpec >= 3 } ->
-			unify_proc__generate_du_three_compare_clauses(
-				Ctor1, Ctor2, Ctor3, Res, H1, H2,
-				Context, Clauses)
 		;
-			unify_proc__generate_du_general_compare_clauses(Type,
+			unify_proc__generate_du_linear_compare_clauses(Type,
 				Ctors, Res, H1, H2, Context, Clauses)
 		)
-	;
-		{ Ctors = [_, _, _, _ | _] },
-		unify_proc__generate_du_general_compare_clauses(Type,
-			Ctors, Res, H1, H2, Context, Clauses)
 	).
 
-unify_proc__max_exploited_compare_spec_value = 3.
-
 %-----------------------------------------------------------------------------%
 
 %	For a du type with one function symbol, such as 
 %
 %		:- type foo ---> f(a, b, c)
 %
-%   	we want to generate code
+%   	the "quadratic" code we want to generate is
 %
 %		compare(Res, X, Y) :-
 %			X = f(X1, X2, X3), Y = f(Y1, Y2, Y3),
@@ -1138,11 +1112,11 @@
 
 %-----------------------------------------------------------------------------%
 
-%	For a du type with two or three function symbols, such as 
+%	For a du type with N function symbols for N > 1, such as 
 %
 %		:- type foo ---> f(a) ; g(a, b, c)
 %
-%   	we want to generate code such as
+%   	the quadratic code we want to generate is
 %
 %		compare(Res, X, Y) :-
 %			(
@@ -1168,66 +1142,67 @@
 %					compare(R, X3, Y3)
 %				)
 %			).
-
-:- pred unify_proc__generate_du_two_compare_clauses(
-	constructor::in, constructor::in, prog_var::in, prog_var::in,
-	prog_var::in, prog_context::in, list(clause)::out,
-	unify_proc_info::in, unify_proc_info::out) is det.
 
-unify_proc__generate_du_two_compare_clauses(Ctor1, Ctor2, R, X, Y,
-		Context, Clauses) -->
-	unify_proc__generate_compare_case(Ctor1, R, X, Y, Context, Case11),
-	unify_proc__generate_compare_case(Ctor2, R, X, Y, Context, Case22),
-	unify_proc__generate_asymmetric_compare_case(Ctor1, Ctor2, "<",
-		R, X, Y, Context, Case12),
-	unify_proc__generate_asymmetric_compare_case(Ctor2, Ctor1, ">",
-		R, X, Y, Context, Case21),
+:- pred unify_proc__generate_du_quad_compare_clauses(list(constructor)::in,
+	prog_var::in, prog_var::in, prog_var::in, prog_context::in,
+	list(clause)::out, unify_proc_info::in, unify_proc_info::out) is det.
 
+unify_proc__generate_du_quad_compare_clauses(Ctors, R, X, Y, Context,
+		Clauses) -->
+	unify_proc__generate_du_quad_compare_clauses_1(Ctors, Ctors, R, X, Y,
+		Context, [], Cases),
 	{ goal_info_init(GoalInfo0) },
 	{ goal_info_set_context(GoalInfo0, Context, GoalInfo) },
 	{ map__init(Empty) },
-	{ Goal = disj([Case11, Case12, Case21, Case22], Empty) - GoalInfo },
+	{ Goal = disj(Cases, Empty) - GoalInfo },
 	{ HeadVars = [R, X, Y] },
 	unify_proc__quantify_clauses_body(HeadVars, Goal, Context, Clauses).
 
-:- pred unify_proc__generate_du_three_compare_clauses(
-	constructor::in, constructor::in, constructor::in,
+:- pred unify_proc__generate_du_quad_compare_clauses_1(
+	list(constructor)::in, list(constructor)::in,
 	prog_var::in, prog_var::in, prog_var::in, prog_context::in,
-	list(clause)::out, unify_proc_info::in, unify_proc_info::out) is det.
+	list(hlds_goal)::in, list(hlds_goal)::out,
+	unify_proc_info::in, unify_proc_info::out) is det.
 
-unify_proc__generate_du_three_compare_clauses(Ctor1, Ctor2, Ctor3, R, X, Y,
-		Context, Clauses) -->
-	unify_proc__generate_compare_case(Ctor1, R, X, Y, Context, Case11),
-	unify_proc__generate_compare_case(Ctor2, R, X, Y, Context, Case22),
-	unify_proc__generate_compare_case(Ctor3, R, X, Y, Context, Case33),
-	unify_proc__generate_asymmetric_compare_case(Ctor1, Ctor2, "<",
-		R, X, Y, Context, Case12),
-	unify_proc__generate_asymmetric_compare_case(Ctor1, Ctor3, "<",
-		R, X, Y, Context, Case13),
-	unify_proc__generate_asymmetric_compare_case(Ctor2, Ctor3, "<",
-		R, X, Y, Context, Case23),
-	unify_proc__generate_asymmetric_compare_case(Ctor2, Ctor1, ">",
-		R, X, Y, Context, Case21),
-	unify_proc__generate_asymmetric_compare_case(Ctor3, Ctor1, ">",
-		R, X, Y, Context, Case31),
-	unify_proc__generate_asymmetric_compare_case(Ctor3, Ctor2, ">",
-		R, X, Y, Context, Case32),
+unify_proc__generate_du_quad_compare_clauses_1([],
+		_RightCtors, _R, _X, _Y, _Context, Cases, Cases) --> [].
+unify_proc__generate_du_quad_compare_clauses_1([LeftCtor | LeftCtors],
+		RightCtors, R, X, Y, Context, Cases0, Cases) -->
+	unify_proc__generate_du_quad_compare_clauses_2(LeftCtor, RightCtors,
+		">", R, X, Y, Context, Cases0, Cases1),
+	unify_proc__generate_du_quad_compare_clauses_1(LeftCtors, RightCtors,
+		R, X, Y, Context, Cases1, Cases).
 
-	{ goal_info_init(GoalInfo0) },
-	{ goal_info_set_context(GoalInfo0, Context, GoalInfo) },
-	{ map__init(Empty) },
-	{ Goal = disj([Case11, Case12, Case13, Case21, Case22, Case23,
-		Case31, Case32, Case33], Empty) - GoalInfo },
-	{ HeadVars = [R, X, Y] },
-	unify_proc__quantify_clauses_body(HeadVars, Goal, Context, Clauses).
+:- pred unify_proc__generate_du_quad_compare_clauses_2(
+	constructor::in, list(constructor)::in, string::in,
+	prog_var::in, prog_var::in, prog_var::in, prog_context::in,
+	list(hlds_goal)::in, list(hlds_goal)::out,
+	unify_proc_info::in, unify_proc_info::out) is det.
 
+unify_proc__generate_du_quad_compare_clauses_2(_LeftCtor,
+		[], _Cmp, _R, _X, _Y, _Context, Cases, Cases) --> [].
+unify_proc__generate_du_quad_compare_clauses_2(LeftCtor,
+		[RightCtor | RightCtors], Cmp0, R, X, Y, Context,
+		Cases0, Cases) -->
+	( { LeftCtor = RightCtor } ->
+		unify_proc__generate_compare_case(LeftCtor, R, X, Y, Context,
+			Case),
+		{ Cmp1 = "<" }
+	;
+		unify_proc__generate_asymmetric_compare_case(LeftCtor,
+			RightCtor, Cmp0, R, X, Y, Context, Case),
+		{ Cmp1 = Cmp0 }
+	),
+	unify_proc__generate_du_quad_compare_clauses_2(LeftCtor, RightCtors,
+		Cmp1, R, X, Y, Context, [Case | Cases0], Cases).
+
 %-----------------------------------------------------------------------------%
 
-%	For a du type with four or more function symbols, such as 
+%	For a du type, such as 
 %
 %		:- type foo ---> f ; g(a) ; h(b, foo).
 %
-%   	we want to generate code
+%   	the linear code we want to generate is
 %
 %		compare(Res, X, Y) :-
 %			__Index__(X, X_Index),	% Call_X_Index
@@ -1259,25 +1234,25 @@
 %				compare_error 	% Abort
 %			).
 
-:- pred unify_proc__generate_du_general_compare_clauses((type)::in,
+:- pred unify_proc__generate_du_linear_compare_clauses((type)::in,
 	list(constructor)::in, prog_var::in, prog_var::in, prog_var::in,
 	prog_context::in, list(clause)::out,
 	unify_proc_info::in, unify_proc_info::out) is det.
 
-unify_proc__generate_du_general_compare_clauses(Type, Ctors, Res, X, Y,
+unify_proc__generate_du_linear_compare_clauses(Type, Ctors, Res, X, Y,
 		Context, [Clause]) -->
-	unify_proc__generate_du_compare_clauses_2(Type, Ctors, Res,
+	unify_proc__generate_du_linear_compare_clauses_2(Type, Ctors, Res,
 		X, Y, Context, Goal),
 	{ HeadVars = [Res, X, Y] },
 	unify_proc__quantify_clause_body(HeadVars, Goal, Context, Clause).
 
-:- pred unify_proc__generate_du_compare_clauses_2((type)::in,
+:- pred unify_proc__generate_du_linear_compare_clauses_2((type)::in,
 	list(constructor)::in, prog_var::in, prog_var::in, prog_var::in,
 	prog_context::in, hlds_goal::out,
 	unify_proc_info::in, unify_proc_info::out) is det.
 
-unify_proc__generate_du_compare_clauses_2(Type, Ctors, Res, X, Y, Context,
-		Goal) -->
+unify_proc__generate_du_linear_compare_clauses_2(Type, Ctors, Res, X, Y,
+		Context, Goal) -->
 	{ IntType = int_type },
 	{ mercury_public_builtin_module(MercuryBuiltin) },
 	{ construct_type(qualified(MercuryBuiltin, "comparison_result") - 0,
@@ -1338,6 +1313,7 @@
 %		:- type foo ---> f ; g(a) ; h(b, foo).
 %
 %   	we want to generate code
+%
 %		(
 %			X = f,		% UnifyX_Goal
 %			Y = f,		% UnifyY_Goal
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing deep_profiler
cvs diff: Diffing deep_profiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/aditi
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/concurrency
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/graphics
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/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/logged_output
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
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/odbc
cvs diff: Diffing extras/posix
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/stream
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing java
cvs diff: Diffing library
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/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/diff
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
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 tests
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/structure_reuse
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/recompilation
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
--------------------------------------------------------------------------
mercury-reviews mailing list
post:  mercury-reviews at cs.mu.oz.au
administrative address: owner-mercury-reviews at cs.mu.oz.au
unsubscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: unsubscribe
subscribe:   Address: mercury-reviews-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------
Previous message: [m-rev.] For review: state variable syntax (long diff)
Next message: [m-rev.] for review: generalize the specialization of compare/3 predicates
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the reviews mailing list