[m-rev.] for post-commit review: cons_table redesign

Zoltan Somogyi zs at csse.unimelb.edu.au
Fri Sep 2 12:38:54 AEST 2011
Previous message: [m-rev.] for review: parallel mmc --make and nested sub-modules
Next message: [m-rev.] for review: speedup up tree_bitset.difference
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
Improve the representation of the constructor table.

This diff speeds up tools/speedtest by about 1.5%.

compiler/hlds_data.m:
	Change the representation of the inner constructor table, the one
	that contains the definitions of all the hlds_cons_defns for
	constructors with a given name. This used to be a map from cons_ids
	to lists of hlds_cons_defns, since an unqualified cons_id could match
	more than one cons_defn. However, this required each hlds_cons_defn
	to be stored several times, and in several situations we then had
	to process the duplicates.

	The new representation uses a list in which each hlds_cons_defn
	is present just once. (Since each list contains only the definitions
	of cons_ids with the same name, these lists should be very short.)
	Each hlds_cons_defn is associated both with the fully qualified
	cons_id, and all the other cons_ids that can refer to it. Those others
	may be partially qualified, or they may contain a dummy type_ctor.
	Do searches first by the fully qualified cons_id, and search using
	the others only if the search on the fully qualified cons_ids fails.
	This should not happen after post-typecheck.

compiler/add_type.m:
	If a hlds_cons_defn has the same name and arity as another
	hlds_cons_defn for the same type, do not add it to the cons_table
	under ANY cons_id. The fact that we used to do this was strange,
	since this could affect the future behavior only of compiler passes
	that (due to the duplicate-cons-id error) we would never get to.

	Specify the type-correct version of the cons_id as the main cons_id
	when inserting a hlds_cons_defn into the cons_table.

compiler/type_util.m:
	Minor speedups.

compiler/prog_type.m:
	Document *why* the changes to type_util should be minor speedups.

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/add_type.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/add_type.m,v
retrieving revision 1.45
diff -u -b -r1.45 add_type.m
--- compiler/add_type.m	22 Aug 2011 04:23:13 -0000	1.45
+++ compiler/add_type.m	1 Sep 2011 06:30:47 -0000
@@ -691,10 +691,7 @@
 
     ConsDefn = hlds_cons_defn(TypeCtor, TVarSet, TypeParams, KindMap,
         ExistQVars, Constraints, Args, Context),
-
-    some [!OtherConsIds] (
-        MainConsId = QualifiedConsIdB,
-        !:OtherConsIds = [],
+    get_partial_qualifiers(TypeCtorModuleName, PQInfo, PartialQuals),
 
         % Check that there is at most one definition of a given cons_id
         % in each type.
@@ -714,11 +711,14 @@
             Spec = error_spec(severity_error, phase_parse_tree_to_hlds, [Msg]),
             !:Specs = [Spec | !.Specs]
         ;
-            !:OtherConsIds = [QualifiedConsIdA | !.OtherConsIds]
-        ),
+        some [!OtherConsIds] (
+            % Schedule the addition of the fully-qualified cons_id
+            % into the cons_table.
+            MainConsId = QualifiedConsIdA,
+            !:OtherConsIds = [QualifiedConsIdB],
 
-        % Add the unqualified version of the cons_id to the cons_table,
-        % if appropriate.
+            % Schedule the addition of the unqualified version of the cons_id
+            % to the cons_table, if appropriate.
         (
             NeedQual = may_be_unqualified,
             !:OtherConsIds =
@@ -727,17 +727,16 @@
             NeedQual = must_be_qualified
         ),
 
-        % Add partially qualified versions of the cons_id.
-        get_partial_qualifiers(TypeCtorModuleName, PQInfo, PartialQuals),
+            % Schedule the partially qualified versions of the cons_id.
         list.foldl(add_ctor_to_list(TypeCtor, BaseName, Arity),
             PartialQuals, !OtherConsIds),
 
+            % Do the scheduled additions.
         insert_into_cons_table(MainConsId, !.OtherConsIds, ConsDefn,
             !Ctors)
+        )
     ),
 
-    % Insert the fully-qualified version of this cons_id into the cons_table.
-
     FieldNames = list.map(func(C) = C ^ arg_field_name, Args),
     FirstField = 1,
     add_ctor_field_names(FieldNames, NeedQual, PartialQuals, TypeCtor,
Index: compiler/hlds_data.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/hlds_data.m,v
retrieving revision 1.140
diff -u -b -r1.140 hlds_data.m
--- compiler/hlds_data.m	22 Aug 2011 04:23:13 -0000	1.140
+++ compiler/hlds_data.m	1 Sep 2011 09:05:52 -0000
@@ -103,7 +103,7 @@
     cons_id::in, hlds_cons_defn::out) is det.
 
 :- pred get_all_cons_defns(cons_table::in,
-    assoc_list(cons_id, list(hlds_cons_defn))::out) is det.
+    assoc_list(cons_id, hlds_cons_defn)::out) is det.
 
 :- pred return_other_arities(cons_table::in, sym_name::in, int::in,
     list(int)::out) is det.
@@ -116,87 +116,133 @@
 
 :- implementation.
 
+    % Maps the raw, unqualified name of a functor to information about
+    % all the functors with that name.
 :- type cons_table  ==  map(string, inner_cons_table).
-:- type inner_cons_table == map(cons_id, list(hlds_cons_defn)).
+
+    % Every visible constructor will have exactly one entry in the list,
+    % and this entry lists all the cons_ids by which that constructor
+    % may be known. The cons_ids listed for a given constructor may give
+    % fully, partially or not-at-all qualified versions of the symbol name,
+    % they must agree on the arity, and may give the actual type_ctor
+    % or the standard dummy type_ctor. The main cons_id must give the
+    % fully qualified symname and the right type_ctor.
+    %
+    % The order of the list is not meaningful.
+:- type inner_cons_table == list(inner_cons_entry).
+:- type inner_cons_entry
+    --->    inner_cons_entry(
+                ice_fully_qual_cons_id      :: cons_id,
+                ice_other_cons_ids          :: list(cons_id),
+                ice_cons_defn               :: hlds_cons_defn
+            ).
 
 init_cons_table = map.init.
 
 insert_into_cons_table(MainConsId, OtherConsIds, ConsDefn, !ConsTable) :-
     ( MainConsId = cons(MainSymName, _, _) ->
         MainName = unqualify_name(MainSymName),
-        ( map.search(!.ConsTable, MainName, InnerConsTable0) ->
-            insert_into_inner_cons_table(MainName, [MainConsId | OtherConsIds],
-                ConsDefn, InnerConsTable0, InnerConsTable),
-            map.det_update(MainName, InnerConsTable, !ConsTable)
-        ;
-            insert_into_inner_cons_table(MainName, [MainConsId | OtherConsIds],
-                ConsDefn, map.init, InnerConsTable),
-            map.det_insert(MainName, InnerConsTable, !ConsTable)
+        Entry = inner_cons_entry(MainConsId, OtherConsIds, ConsDefn),
+        ( map.search(!.ConsTable, MainName, InnerConsEntries0) ->
+            InnerConsEntries = [Entry | InnerConsEntries0],
+            map.det_update(MainName, InnerConsEntries, !ConsTable)
+        ;
+            InnerConsEntries = [Entry],
+            map.det_insert(MainName, InnerConsEntries, !ConsTable)
         )
     ;
         unexpected($module, $pred, "MainConsId is not cons")
     ).
 
-:- pred insert_into_inner_cons_table(string::in, list(cons_id)::in,
-    hlds_cons_defn::in, inner_cons_table::in, inner_cons_table::out) is det.
-
-insert_into_inner_cons_table(_MainName, [], _ConsDefn, !InnerConsTable).
-insert_into_inner_cons_table(MainName, [ConsId | ConsIds], ConsDefn,
-        !InnerConsTable) :-
-    ( ConsId = cons(SymName, _, _) ->
-        Name = unqualify_name(SymName),
-        ( Name = MainName ->
-            multi_map.set(ConsId, ConsDefn, !InnerConsTable)
-        ;
-            unexpected($module, $pred, "SymName mismatch")
-        )
-    ;
-        unexpected($module, $pred, "ConsId is not cons")
-    ),
-    insert_into_inner_cons_table(MainName, ConsIds, ConsDefn, !InnerConsTable).
-
 search_cons_table(ConsTable, ConsId, ConsDefns) :-
     ConsId = cons(SymName, _, _),
     Name = unqualify_name(SymName),
     map.search(ConsTable, Name, InnerConsTable),
-    map.search(InnerConsTable, ConsId, ConsDefns).
+
+    % After post-typecheck, all calls should specify the main cons_id
+    % of the searched-for (single) constructor definition. Searching
+    % the main cons_ids is sufficient for such calls, and since there are
+    % many fewer main cons_ids than other cons_ids, it is fast as well.
+    %
+    % I (zs) don't think replacing a list with a different structure would
+    % help, since these lists should be very short.
+
+    ( search_inner_main_cons_ids(InnerConsTable, ConsId, MainConsDefn) ->
+        ConsDefns = [MainConsDefn]
+    ;
+        % Before and during typecheck, we may need to look up constructors
+        % using cons_ids that may not be even partially module qualified,
+        % and which will contain a dummy type_ctor. That is why we search
+        % the other cons_ids as well.
+        %
+        % After post-typecheck, we should get here only if there is a bug
+        % in the compiler, since
+        %
+        % - at that time, all cons_ids should be module-qualified and should
+        %   have non-dummy type-ctors,
+        %
+        % - this means that searches that find what they are looking for
+        %   will take the then-branch above, and
+        %
+        % - there should be no searches that fail, because mention of
+        %   an unknown cons_id in the program is a type error, which means
+        %   the compiler should never get to the passes following
+        %   post-typecheck.
+
+        search_inner_other_cons_ids(InnerConsTable, ConsId, ConsDefns),
+        % Do not return empty lists; let the call fail in that case.
+        ConsDefns = [_ | _]
+    ).
+
+:- pred search_inner_main_cons_ids(list(inner_cons_entry)::in, cons_id::in,
+    hlds_cons_defn::out) is semidet.
+
+search_inner_main_cons_ids([Entry | Entries], ConsId, ConsDefn) :-
+    ( ConsId = Entry ^ ice_fully_qual_cons_id ->
+        ConsDefn = Entry ^ ice_cons_defn
+    ;
+        search_inner_main_cons_ids(Entries, ConsId, ConsDefn)
+    ).
+
+:- pred search_inner_other_cons_ids(list(inner_cons_entry)::in, cons_id::in,
+    list(hlds_cons_defn)::out) is det.
+
+search_inner_other_cons_ids([], _ConsId, []).
+search_inner_other_cons_ids([Entry | Entries], ConsId, !:ConsDefns) :-
+    search_inner_other_cons_ids(Entries, ConsId, !:ConsDefns),
+    ( list.member(ConsId, Entry ^ ice_other_cons_ids) ->
+        !:ConsDefns = [Entry ^ ice_cons_defn | !.ConsDefns]
+    ;
+        true
+    ).
 
 search_cons_table_of_type_ctor(ConsTable, TypeCtor, ConsId, ConsDefn) :-
     ConsId = cons(SymName, _, _),
     Name = unqualify_name(SymName),
     map.search(ConsTable, Name, InnerConsTable),
-    map.search(InnerConsTable, ConsId, AllConsDefns),
-    search_cons_defns_for_type_ctor(TypeCtor, AllConsDefns, ConsDefn).
+    search_inner_cons_ids_type_ctor(InnerConsTable, TypeCtor, ConsId,
+        ConsDefn).
 
-:- pred search_cons_defns_for_type_ctor(type_ctor::in,
-    list(hlds_cons_defn)::in, hlds_cons_defn::out) is semidet.
+:- pred search_inner_cons_ids_type_ctor(list(inner_cons_entry)::in,
+    type_ctor::in, cons_id::in, hlds_cons_defn::out) is semidet.
 
-search_cons_defns_for_type_ctor(TypeCtor, [HeadConsDefn | TailConsDefns],
+search_inner_cons_ids_type_ctor([Entry | Entries], TypeCtor, ConsId,
         ConsDefn) :-
-    ( HeadConsDefn ^ cons_type_ctor = TypeCtor ->
-        verify_cons_defns_for_type_ctor(TypeCtor, HeadConsDefn, TailConsDefns,
-            ConsDefn)
-    ;
-        search_cons_defns_for_type_ctor(TypeCtor, TailConsDefns, ConsDefn)
-    ).
-
-:- pred verify_cons_defns_for_type_ctor(type_ctor::in, hlds_cons_defn::in,
-    list(hlds_cons_defn)::in, hlds_cons_defn::out) is semidet.
-
-verify_cons_defns_for_type_ctor(_TypeCtor, FirstConsDefn, [], FirstConsDefn).
-verify_cons_defns_for_type_ctor(TypeCtor, FirstConsDefn,
-        [HeadConsDefn | TailConsDefns], ConsDefn) :-
-    ( HeadConsDefn ^ cons_type_ctor = TypeCtor ->
-        ( HeadConsDefn = FirstConsDefn ->
-            verify_cons_defns_for_type_ctor(TypeCtor, FirstConsDefn,
-                TailConsDefns, ConsDefn)
-        ;
-            unexpected($module, $pred,
-                "different cons_defns for same cons_id in same type")
+    EntryConsDefn = Entry ^ ice_cons_defn,
+    (
+        % If a type has two functors with the same name but different arities,
+        % then it is possible for the TypeCtor test to succeed and the ConsId
+        % tests to fail (due to the arity mismatch). In such cases, we need
+        % to search the rest of the list.
+
+        EntryConsDefn ^ cons_type_ctor = TypeCtor,
+        ( ConsId = Entry ^ ice_fully_qual_cons_id
+        ; list.member(ConsId, Entry ^ ice_other_cons_ids)
         )
+    ->
+        ConsDefn = EntryConsDefn
     ;
-        verify_cons_defns_for_type_ctor(TypeCtor, FirstConsDefn,
-            TailConsDefns, ConsDefn)
+        search_inner_cons_ids_type_ctor(Entries, TypeCtor, ConsId, ConsDefn)
     ).
 
 lookup_cons_table_of_type_ctor(ConsTable, TypeCtor, ConsId, ConsDefn) :-
@@ -213,25 +259,62 @@
     map.foldl(accumulate_all_inner_cons_defns, ConsTable, [], AllConsDefns).
 
 :- pred accumulate_all_inner_cons_defns(string::in, inner_cons_table::in,
-    assoc_list(cons_id, list(hlds_cons_defn))::in,
-    assoc_list(cons_id, list(hlds_cons_defn))::out) is det.
+    assoc_list(cons_id, hlds_cons_defn)::in,
+    assoc_list(cons_id, hlds_cons_defn)::out) is det.
 
 accumulate_all_inner_cons_defns(_Name, InnerConsTable, !AllConsDefns) :-
-    map.to_assoc_list(InnerConsTable, InnerConsList),
+    list.map(project_inner_cons_entry, InnerConsTable, InnerConsList),
     !:AllConsDefns = InnerConsList ++ !.AllConsDefns.
 
+:- pred project_inner_cons_entry(inner_cons_entry::in,
+    pair(cons_id, hlds_cons_defn)::out) is det.
+
+project_inner_cons_entry(Entry, Pair) :-
+    Entry = inner_cons_entry(MainConsId, _OtherConsIds, ConsDefn),
+    Pair = MainConsId - ConsDefn.
+
 return_other_arities(ConsTable, SymName, Arity, OtherArities) :-
     Name = unqualify_name(SymName),
     ( map.search(ConsTable, Name, InnerConsTable) ->
-        solutions.solutions(
-            (pred(N::out) is nondet :-
-                map.member(InnerConsTable, cons(SymName, N, _), _),
-                N \= Arity
-            ), OtherArities)
+        return_other_arities_inner(InnerConsTable, SymName, Arity,
+            [], OtherArities0),
+        list.sort_and_remove_dups(OtherArities0, OtherArities)
     ;
         OtherArities = []
     ).
 
+:- pred return_other_arities_inner(list(inner_cons_entry)::in,
+    sym_name::in, int::in, list(int)::in, list(int)::out) is det.
+
+return_other_arities_inner([], _, _, !OtherArities).
+return_other_arities_inner([Entry | Entries], SymName, Arity, !OtherArities) :-
+    MainConsId = Entry ^ ice_fully_qual_cons_id,
+    OtherConsIds = Entry ^ ice_other_cons_ids,
+    return_other_arities_inner_cons_ids([MainConsId | OtherConsIds],
+        SymName, Arity, !OtherArities),
+    return_other_arities_inner(Entries, SymName, Arity, !OtherArities).
+
+:- pred return_other_arities_inner_cons_ids(list(cons_id)::in,
+    sym_name::in, int::in, list(int)::in, list(int)::out) is det.
+
+return_other_arities_inner_cons_ids([], _, _, !OtherArities).
+return_other_arities_inner_cons_ids([ConsId | ConsIds], SymName, Arity,
+        !OtherArities) :-
+    ( ConsId = cons(ThisSymName, ThisArity, _) ->
+        (
+            ThisSymName = SymName,
+            ThisArity \= Arity
+        ->
+            !:OtherArities = [ThisArity | !.OtherArities]
+        ;
+            true
+        )
+    ;
+        unexpected($module, $pred, "ConsId is not cons")
+    ),
+    return_other_arities_inner_cons_ids(ConsIds, SymName, Arity,
+        !OtherArities).
+
 replace_cons_defns_in_cons_table(Replace, !ConsTable) :-
     map.map_values_only(replace_cons_defns_in_inner_cons_table(Replace),
         !ConsTable).
@@ -241,15 +324,17 @@
     inner_cons_table::in, inner_cons_table::out) is det.
 
 replace_cons_defns_in_inner_cons_table(Replace, !InnerConsTable) :-
-    map.map_values_only(replace_cons_defns_in_cons_defns(Replace),
+    list.map(replace_cons_defns_in_inner_cons_entry(Replace),
         !InnerConsTable).
 
-:- pred replace_cons_defns_in_cons_defns(
+:- pred replace_cons_defns_in_inner_cons_entry(
     pred(hlds_cons_defn, hlds_cons_defn)::in(pred(in, out) is det),
-    list(hlds_cons_defn)::in, list(hlds_cons_defn)::out) is det.
+    inner_cons_entry::in, inner_cons_entry::out) is det.
 
-replace_cons_defns_in_cons_defns(Replace, !ConsDefns) :-
-    list.map(Replace, !ConsDefns).
+replace_cons_defns_in_inner_cons_entry(Replace, !Entry) :-
+    ConsDefn0 = !.Entry ^ ice_cons_defn,
+    Replace(ConsDefn0, ConsDefn),
+    !Entry ^ ice_cons_defn := ConsDefn.
 
 cons_table_optimize(!ConsTable) :-
     map.optimize(!ConsTable).
Index: compiler/prog_type.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/prog_type.m,v
retrieving revision 1.56
diff -u -b -r1.56 prog_type.m
--- compiler/prog_type.m	21 Jul 2011 06:58:26 -0000	1.56
+++ compiler/prog_type.m	1 Sep 2011 09:28:54 -0000
@@ -540,9 +540,11 @@
     ).
 
 type_to_ctor(Type, TypeCtor) :-
+    % This should be subject to unused argument elimination.
     type_to_ctor_and_args(Type, TypeCtor, _Args).
 
 type_to_ctor_det(Type, TypeCtor) :-
+    % This should be subject to unused argument elimination.
     type_to_ctor_and_args_det(Type, TypeCtor, _Args).
 
 type_ctor_is_higher_order(TypeCtor, Purity, PredOrFunc, EvalMethod) :-
Index: compiler/type_util.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/type_util.m,v
retrieving revision 1.211
diff -u -b -r1.211 type_util.m
--- compiler/type_util.m	31 Aug 2011 07:59:35 -0000	1.211
+++ compiler/type_util.m	1 Sep 2011 09:20:09 -0000
@@ -930,7 +930,7 @@
 %-----------------------------------------------------------------------------%
 
 switch_type_num_functors(ModuleInfo, Type, NumFunctors) :-
-    type_to_ctor_and_args(Type, TypeCtor, _),
+    type_to_ctor(Type, TypeCtor),
     ( TypeCtor = type_ctor(unqualified("character"), 0) ->
         % XXX The following code uses the source machine's character size,
         % not the target's, so it won't work if cross-compiling to a machine
@@ -1051,13 +1051,13 @@
         ExistQVars, Constraints, Args, _Context),
     ArgTypes = list.map(func(C) = C ^ arg_type, Args),
     prog_type.var_list_to_type_list(KindMap, TypeParams, TypeCtorArgs),
-    type_to_ctor_and_args(VarType, TypeCtor, _),
+    type_to_ctor(VarType, TypeCtor),
     construct_type(TypeCtor, TypeCtorArgs, RetType),
     CtorDefn = ctor_defn(TypeVarSet, ExistQVars, KindMap, Constraints,
         ArgTypes, RetType).
 
 is_existq_cons(ModuleInfo, VarType, ConsId, ConsDefn) :-
-    type_to_ctor_and_args(VarType, TypeCtor, _),
+    type_to_ctor(VarType, TypeCtor),
     get_cons_defn(ModuleInfo, TypeCtor, ConsId, ConsDefn),
     ConsDefn ^ cons_exist_tvars = [_ | _].
 
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
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: parallel mmc --make and nested sub-modules
Next message: [m-rev.] for review: speedup up tree_bitset.difference
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the reviews mailing list