29 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	1c3bc03415	Make the system compiler with --warn-unused-imports. ... Estimated hours taken: 2 Branches: main, release Make the system compiler with --warn-unused-imports. browser/*.m: library/*.m: compiler/*.m: Remove unnecesary imports as flagged by --warn-unused-imports. In some files, do some minor cleanup along the way.	2010-12-30 11:18:04 +00:00
Zoltan Somogyi	8a28e40c9b	Add the predicates sorry, unexpected and expect to library/error.m. ... Estimated hours taken: 2 Branches: main Add the predicates sorry, unexpected and expect to library/error.m. compiler/compiler_util.m: library/error.m: Move the predicates sorry, unexpected and expect from compiler_util to error. Put the predicates in error.m into the same order as their declarations. compiler/*.m: Change imports as needed. compiler/lp.m: compiler/lp_rational.m: Change imports as needed, and some minor cleanups. deep_profiler/*.m: Switch to using the new library predicates, instead of calling error directly. Some other minor cleanups. NEWS: Mention the new predicates in the standard library.	2010-12-15 06:30:36 +00:00
Zoltan Somogyi	543fc6e342	Change the way the typechecker iterates over the predicates of the program. ... Estimated hours taken: 12 Branches: main Change the way the typechecker iterates over the predicates of the program. We used to do it by looking up each predicate in the module_info, typechecking it, and putting it back into the module_info. We now do it by converting the predicate table into a list, iterating over the list transforming each pred_info in it, converting the updated list back to a predicate table. The original intention of this change was to allow different predicates to be typechecked in parallel by removing a synchronization bottleneck: the typechecking of a predicate now doesn't have to wait for the typechecking of the previous predicate to generate the updated version of the module_info. However, it turned out that the change is good for sequential execution as well, improving the time on tools/speedtest from 11.33 seconds to 11.08 seconds, a speedup of 2.2%. On tools/speedtest -l, which tests the compilation of more modules, the speedup is even better: 3.1% (from 32.63 to 31.60s). compiler/typecheck.m: Implement the above change. compiler/hlds_module.m: compiler/pred_table.m: Add a new operation, setting the list of valid pred_ids, now needed by typecheck.m, to both modules. Make the names of the predicates for accessing the predicate table more expressive, and make them conform to our naming conventions. compiler/*.m: Trivial changes to conform to the change in hlds_module.m. library/assoc_list.m: Add new predicates used by the new version of typecheck.m (at some time in its development). NEWS: Mention the new predicates. library/list.m: Improve documentation that is now copied to assoc_list.m. tools/speedtest: Make the test command more easily configurable.	2010-07-30 05:16:26 +00:00
Zoltan Somogyi	30aafc69a0	Split up three big compiler modules: llds_out.m, hlds_out.m (5000+ lines each) ... Estimated hours taken: 12 Branches: main Split up three big compiler modules: llds_out.m, hlds_out.m (5000+ lines each) and deep_profiling.m (3000+ lines). Put the predicates in the resulting smaller modules into cohesive groups where possible. A few of the predicates in the original modules were unused; this diff deletes them. There are no algorithmic changes. compiler/llds_out_code_addr.m: New module containing the part of llds_out.m that outputs code addresses and labels. compiler/llds_out_data.m: New module containing the part of llds_out.m that outputs lvals, rvals and their components. compiler/llds_out_global.m: New module containing the part of llds_out.m that generates global static C data structures. compiler/llds_out_instr.m: New module containing the part of llds_out.m that outputs instructions compiler/llds_out_file.m: New module containing the top level part of llds_out.m, which coordinates the generation of a whole C source file. compiler/llds_out_util.m: New module containing the utility parts of llds_out.m. compiler/llds_out.m: Replace everything in this file with just the includes of the submodules that now have all its previous contents. compiler/hlds_llds.m: Move a predicate here from llds_out.m, since it is a utility predicate operating on a type defined here. compiler/rtti_out.m: Move a predicate here from llds_out.m, since it is a predicate generating output from a rtti type. compiler/hlds_out_mode.m: The part of hlds_out.m that deals with writing out insts and modes. compiler/hlds_out_goal.m: The part of hlds_out.m that deals with writing out goals. compiler/hlds_out_pred.m: The part of hlds_out.m that deals with writing out predicates and procedures. compiler/hlds_out_module.m: The part of hlds_out.m that deals with writing out module-wide tables. compiler/hlds_out_util.m: Parts of hlds_out.m that don't fit in anywhere else. compiler/hlds_out.m: Replace everything in this file with just the includes of the submodules that now have all its previous contents. compiler/simplify.m: compiler/hlds_goal.m: Move some insts from simplify.m to hlds_goal.m to allow hlds_out_goal.m to use them also. compiler/coverage_profiling.m: The part of deep_profiling.m that deals with coverage profiling. compiler/deep_profiling.m: Remove the code moved to coverage_profiling.m, and export the utility predicates needed by coverage_profiling.m. Remove the things moved to prog_data.m and hlds_goal.m. Put the predicates into a more logical order. compiler/hlds_goal.m: Move some predicates here from deep_profiling.m, since they belong here. compiler/prog_data.m: Move a type from deep_profiling.m here, since it belongs here. compiler/add_pragma.m: Add a predicate from llds_out.m that is used only here. compiler/*.m: Conform to the changes above.	2009-11-04 03:44:52 +00:00
Zoltan Somogyi	77a6a6c10c	Implement several more changes that together speed up compilation time ... Estimated hours taken: 16 Branches: main Implement several more changes that together speed up compilation time on training_cars_full by 12%, and also improve tools/speedtest -h by 7.2% and tools/speedtest by 1.6%. The first change is designed to eliminate the time that the compiler spends constructing error messages that are then ignored. The working predicates of prog_io_sym_name used to always return a single result, which either gave a description of the thing being looked, or an error message. However, in many places, the caller did not consider not finding the thing being looked for to be an error, and thus threw away the error message, keeping only the "not found" indication. For each predicate with such callers, this diff provides a parallel predicate that indicates "not found" simply by failing. This allows us to eliminate the construction of the error message, the preparation for the construction of the error message (usually by describing the context), and the construction of the "ok" wrapper. The second change is to specialize the handling of from_ground_term_construct scopes in the termination analyzer. To make this easier, I also cleaned up of the infrastructure of the termination analyzer. The third change is to avoid traversing from_ground_term_construct scopes in quantification.m when finding the variables in a goal, since termination analysis no longer needs the information it gathers. The fourth change is to avoid traversing second and later conjuncts in conjunctions twice. The first step in handling conjunctions is to call implicitly_quantify_conj, which builds up a data structure that pairs each conjunct with the variables that occur free in all the conjuncts following it. However, after this was done and each conjunct was annotated with its nonlocals, we used to compute the variables that occur free in the conjunction as a whole from scratch. This diff changes the code so that we now compute that set based on the information we gathered earlier, avoiding a redundant traversal. The fifth change is to create specialized, lower-arity versions of many of the predicates in quantification.m. These versions are intended for traversals that take place after the compiler has replaced lambda expressions with references to separate procedures. These traversals do not need to pass around arguments representing the variables occurring free in the (now non-existent) lambda expressions. compiler/prog_io_sym_name.m: Make the first change described above. Change some predicate names to adopt a consistent naming scheme in which predicates that do the same job and differ only in how they handle errors have names that differ only in a "try_" prefix. Add some predicate versions that do common tests on the output of the base versions. For example, try_parse_sym_name_and_no_args is a version of try_parse_sym_name_and_args that insists on finding an empty argument list. Remove the unused "error term" argument that we used to need a while ago. Move some predicate definitions to make their order match the order of their declarations. Turn a predicate into a function for its caller's convenience. compiler/term_constr_build.m: Make the second change described above by modeling each from_ground_term_construct scope as a single unification, assigning the total size of the ground term to the variable being built. compiler/term_constr_util.m: Put the arguments of some predicates into a more standard order. compiler/lp_rational.m: Change the names of some function symbols to avoid both the use of graphic characters that require quoting and clashes with other types. Change the names of some predicates to make their purpose clear, and to avoid ambiguity. compiler/quantification.m: Make the third, fourth and fifth changes described above. compiler/*.m: Conform to the changes above.	2009-09-08 02:43:41 +00:00
Zoltan Somogyi	40d4f2e3cf	Rename some types, functors, field names and predicate names to remove ... Estimated hours taken: 1 Branches: main compiler/term_constr_build.m: compiler/term_constr_data.m: compiler/term_constr_main.m: Rename some types, functors, field names and predicate names to remove ambiguities. Replace some lambda expressions with named predicates. Reorder some arguments to make higher order programming easier.	2009-07-20 00:46:12 +00:00
Zoltan Somogyi	d69ba1a1f0	Include the type_ctor in cons_ids for user-defined types. ... Estimated hours taken: 32 Branches: main Include the type_ctor in cons_ids for user-defined types. The intention is two-fold: - It prepares for a future in which we allow more than one function symbol to with the same name to be defined in a module. - It makes the HLDS code more self-contained. In many places, processing construction and deconstruction unifications required knowing which type the cons_id belongs to, but until now, code couldn't know that unless it kept track of the type of the variable unified with the cons_id. With this diff, user-defined cons_ids are represented as cons(SymName, Arity, TypeCtor) The last field is filled in during post-typecheck. After that time, any module qualification in the SymName (which may initially be partial) is redundant, since it is also available in the TypeCtor. In the future, we could make all those SymNames be just unqualified(_) at that time. We could also replace the current maps in HLDS type definitions with full cons_id keys with just name/arity keys (since the module qualifier is a given for any given type definition), we could also support partially qualified cons_ids in source code using a map from name/arity pairs to a list of all the type_ctors that have function symbols with that name/arity, instead of our current practice of inserting all possible partially module qualified version of every cons_id into a single giant table, and we could do the same thing with the field names table. This diff also separates tuples out from user-defined types, since in many respects they are different (they don't have a single type_ctor, for starters). It also separates out character constants, since they were alreay treated specially in most places, though not in some places where they *ought* to have been treated specially. Take the opportunity to give some other cons_ids better names. compiler/prog_data.m: Make the change described above, and document it. Put the implementations of the predicates declared in each part of this module next to the declarations, instead of keeping all the code until the very end (where it was usually far from their declarations). Remove three predicates with identical definitions from inst_match.m, inst_util.m and mode_constraints.m, and put the common definition in prog_data.m. library/term_io.m: Add a new predicate that is basically a reversible version of the existing function espaced_char, since the definition of char_consts needs reversibilty. compiler/post_typecheck.m: For functors of user-defined types, record their type_ctor. For tuples and char constants, record them as such. compiler/builtin_lib_types.m: compiler/parse_tree.m: compiler/notes/compiler_design.html: New module to centralize knowledge about builtin types, specially handled library types, and their function symbols. Previously, the stuff now in this module used to be in several different places, including prog_type.m and stm_expand.m, and some of it was duplicated. mdbcomp/prim_data.m: Add some predicates now needed by builtin_lib_types.m. compiler/builtin_ops.m: Factor out some duplicated code. compiler/add_type.m: Include the relevant type_ctors in the cons_ids generated in type definitions. compiler/hlds_data.m: Document an existing type better. Rename a cons_tag in sync with its corresponding cons_id. Put some declarations into logical order. compiler/hlds_out.m: Rename a misleadingly-named predicate. compiler/prog_ctgc.m: compiler/term_constr_build.m: Add XXXs for questionable existing code. compiler/add_clause.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/bytecode_gen.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/complexity.m: compiler/ctgc_selector.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/delay_partial_inst.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/erl_rtti.m: compiler/erl_unify_gen.m: compiler/export.m: compiler/field_access.m: compiler/foreign.m: compiler/format_call.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_desc.m: compiler/hlds_goal.m: compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/inst_graph.m: compiler/inst_match.m: compiler/inst_util.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/make_tags.m: compiler/mercury_compile.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/mlds_to_java.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_ordering.m: compiler/mode_util.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/polymorphism.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/prog_io_util.m: compiler/prog_mode.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/prog_type.m: compiler/prog_util.m: compiler/purity.m: compiler/qual_info.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/simplify.m: compiler/simplify.m: compiler/special_pred.m: compiler/ssdebug.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbagem: compiler/superhomoegenous.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/try_expand.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unify_modes.m: compiler/untupling.m: compiler/unused_imports.m: compiler/xml_documentation.m: Minor changes, mostly to ignore the type_ctor in cons_ids in places where it is not needed, take the type_ctor from the cons_id in places where it is more convenient, conform to the new names of some cons_ids, conform to the changes in hlds_out.m, and/or add now-needed imports of builtin_lib_types.m. In some places, the handling previously applied to cons/2 (which included tuples and character constants as well as user-defined function symbols) is now applied only to user-defined function symbols or to user-defined function symbols and tuples, as appropriate, with character constants being handled more like the other kinds of constants. In inst_match.m, rename a whole bunch of predicates to avoid ambiguities. In prog_util.m, remove two predicates that did almost nothing yet were far too easy to misuse.	2009-06-11 07:00:38 +00:00
Zoltan Somogyi	5ad9a27793	Speed up the compiler's handling of code that constructs large ground terms ... Estimated hours taken: 80 Branches: main Speed up the compiler's handling of code that constructs large ground terms by specializing the treatment of such code. This diff reduces the compilation time for training_cars_full.m from 106.9 seconds to 30.3 seconds on alys, my laptop. The time on tools/speedtest stays pretty much the same. compiler/hlds_goal.m: Record the classification of from_ground_term scopes as purely constructing terms, purely deconstructing them or something other. Fix an old potential bug: variables inside the construct_how fields of unifications weren't being renamed along with other variables. This is a bug if any part of the compiler later looks at those variables. (I am not sure whether or not this happens.) compiler/superhomogenous.m: Provisionally mark newly constructed static terms as being from_ground_term_construct. Mode checking will either confirm this or change the scope kind. compiler/options.m: compiler/handle_options.m: Add a new option, from_ground_term_threshold, that allows the user to set the boundary between ground terms that get scopes and ground terms do not. I plan to experiment with different settings later. compiler/modes.m: Make this classification. For scopes that construct ground terms, use a specialized algorithm that avoids quadratic behavior. (It does not access the unify_inst_table, which is where the factor of N other than the length of the goal list came from.) The total size of the instmap_deltas, if printed out, still looks like O(N^2) in size, but due to structure sharing it needs only O(N) memory. For scopes that construct ground terms, set the determinism information so that det_analysis.m doesn't have to traverse such scopes. When handling disjunctions, check whether some nonlocals of the disjunctions are constructed by from_ground_term_construct scopes. For any such nonlocals, set their insts to just ground, throwing away the precise information we have about exactly what function symbols they and ALL their subterms are bound to. This is HUGE win, since it allows us avoid spending a lot of time building a huge merge_inst table, which later passes of the compiler (e.g. equiv_type_hlds) would then have to spend similarly huge times traversing. This approach does have a down side. If lots of arms of a disjunction bind a nonlocal to a large ground term, but a few bind it to a SMALL ground term, a term below the from_ground_term_threshold, this optimization won't kick in. That could be one purpose of the new option. It isn't documented yet; I will seek feedback about its usefulness first. compiler/modecheck_unify.m: Handle the three different kinds of right hand sides separately. This yields a small speedup, because now we don't test rhs_vars and rhs_functors (the common right hand sides) for a special case (goals containing "any" insts) that is applicable only to rhs_lambda_goals. compiler/unique_modes.m: Don't traverse scopes that construct ground terms, since modes.m has already done everything that needs to be done. compiler/det_analysis.m: Don't traverse scopes that construct ground terms, since modes.m has already done the needed work. compiler/instmap.m: Add a new predicate for use by modes.m. Many predicate names in this module were quite uninformative; give them informative names. compiler/polymorphism.m: If this pass invalidates the from_ground_term_construct invariants, then mark the relevant scope as from_ground_term_other. Delete two unused access predicates. compiler/equiv_type_hlds.m: Don't traverse scopes that construct ground terms, since modes.m ensures that their instmap deltas do not contain typed insts, and thus the scope cannot contain types that need to be expanded. Convert some predicates to single clauses. compiler/goal_form.m: compiler/goal_util.m: In predicates that test goals for various properties, don't traverse scopes that construct ground terms when the outcome of the test is the same for all such scopes. Convert some predicates to single clauses. compiler/simplify.m: Do not look for common structs in from_ground_term_construct scopes, both because this speeds up the compiler, and because retaining references to ground terms is in fact a pessimization, not an optimization. This is because (a) those references need to be stored in stack slots across calls, and (b) the C code generators ensure that the cells representing ground terms will be shared as needed. If all arms of a switch are from_ground_term_construct scopes, do not merge the instmap_deltas from those arms, since this is both time-consuming (even after the other changes in this diff) and extremely unlikely to improve the instmap_delta. Disable common_struct in from_ground_term_construct scopes, since for these scopes, it is actually a pessimization. Do not delete from_ground_term_construct scopes, since many compiler passes can now use them. Do some manual deforestation, break up some large predicates, and give better names to some. compiler/liveness.m Special-case the handling from_ground_term_construct scopes. This allows us to traverse them just once instead of three times, and this traversal is simpler and faster than any of the three. In some traversals, we were switching on the goal type twice; once in e.g. detect_liveness_in_goal_2, and once by calling goal_expr_has_subgoals. Eliminate the double switching by merging the relevant predicates. (The double-switching structure was easier to work with before we had multi-cons-id switches.) compiler/typecheck.m: Move a lookup after a test, so we don't have to do it if the test fails. Provide a specialized mode for a predicate. This should allow the compiler to eliminate an argument and a test in the common case. Note a possible chance for a speedup. compiler/typecheck_info.m: Don't apply empty substitutions to the types of a possibly very large set of variables. compiler/quantification.m: Don't quantify from_ground_term_construct scopes. They are created correctly quantified, and any compiler pass that invalidates that quantification also removes the from_ground_term_construct mark. Don't apply empty renamings to a possibly very large set of variables. Move the code for handling scopes to its own predicate, to avoid overwhelming the code that handles other kinds of goals. Even from this, factor out the renaming code, since it is needed only for some kinds of scopes. Make some predicate names better reflect what the predicate does. compiler/pd_cost.m: For from_ground_term_construct scopes, instead of computing their cost by adding up the costs of the goals inside, make their cost a constant, since binding a variable to a static term takes constant time. compiler/pd_info.m: Add prefixes on field names to avoid ambiguities. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/closure_analysis.m: compiler/constraint.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/distance_granularity.m: compiler/exception_analysis.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/format_call.m: compiler/granularity.m: compiler/higher_order.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/loop_inv.m: compiler/middle_rec.m: compiler/mode_util.m: compiler/parallel_to_plain_conj.m: compiler/saved_vars.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.lbu.m: compiler/structure_sharing.analysis.m: compiler/switch_detection.analysis.m: compiler/trail_analysis.m: compiler/term_pass1.m: compiler/tupling.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: These passes have nothing to do in from_ground_term_construct scopes, so don't traverse them. In some modules (e.g. dead_proc_elim), some traversals had to be kept. In loop_inv.m, replace a code structure that updated accumulators with functions (which prevented the natural use of state variables), that in lots of places reconstructed the term it had just deconstructed, and obscured the identical handling of different kinds of goals, with a structure based on predicates, state variables and shared code for different goal types where possible. In store_alloc.m, avoid some double switching on the same value. In stratify.m, unneeded_code.m and unused_args.m, rename predicates to avoid ambiguities. compiler/goal_path.m: compiler/goal_util.m: compiler/implementation_defined_literals.m: compiler/intermode.m: compiler/mark_static_terms.m: compiler/ml_code_gen.m: compiler/mode_ordering.m: compiler/ordering_mode_constraints.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_path.m: compiler/rbmm.region_transformation.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/term_const_build.m: compiler/term_traversal.m: compiler/unused_imports.m: Mark places where we cannot (yet) special case from_ground_term_construct scopes. In structure_reuse.lfu.m, turn nested if-then-elses into a switch in. compiler/size_prof.m: Turn from_ground_term_construct scopes into from_ground_term_other scopes, since in term size profiling grades, we need to attach sizes to terms. Give predicates better names. compiler/*.m: Minor changes to conform to the changes above. compiler/make_hlds_passes.m: With -S, print statistics after the third pass over items, since this is the time-consuming one. compiler/mercury_compile.m: Conform to the new names of some predicates. When declining to output a HLDS dump because it would be identical to the previous dump, don't confuse the user either by being silent about the decision, or by leaving an old dump laying around that could be mistaken for a new one. tools/binary: tools/binary_step: Bring these tools up to date. compiler/Mmakefile: Add an int3s target for use by the new code in the tools. The Mmakefiles in the other directories with Mercury code already have such a target. compiler/notes/allocation.html: Fix an out-of-date reference. tests/debugger/polymorphic_ground_term.{m,inp,exp}: New test case to check whether liveness.m handles typeinfo liveness of ground terms correctly. tests/debugger/Mmakefile: Enable the new test case. tests/debugger/polymorphic_output.{m,exp}: Fix tab/space mixup.	2008-12-23 01:38:03 +00:00
Zoltan Somogyi	b000cb322e	Provide compiler support for Software Transactional Memory through the new ... Estimated hours taken: 80 by zs, and lots more by lmika Branches: main Provide compiler support for Software Transactional Memory through the new atomic goal. This work was done by Leon Mika; I merely brought it up to date, resolved conflicts, and cleaned up a few things. There are still several aspects that are as yet incomplete. library/ops.m: Add the operators needed for the syntax of atomic scopes. library/stm_builtin.m: Add the builtin operations needed for the implementation of atomic goals. compiler/hlds_goal.m: Add a new HLDS goal type, which represents an atomic goal and its possible fallbacks (in case an earlier goal throws an exception). Rename the predicate goal_is_atomic as goal_expr_has_subgoals, since now its old name would be misleading. compiler/prog_data.m: compiler/prog_item.m: Add a parse tree representation of the new kind of goal. compiler/prog_io_goal.m: Parse the new kind of goal. compiler/add_clause.m: Translate atomic goals from parse tree form to HLDS. compiler/typecheck.m: compiler/typecheck_errors.m: Do type checking of atomic goals. compiler/modes.m: Do mode checking of atomic goals, and determine whether they are nested or not. compiler/unique_modes.m: Do unique mode checking of atomic goals. compiler/stm_expand.m: New module to expand atomic goals into sequences of simpler goals. library/stm_builtin.m: Add the primitives needed by the transformation. Improve the existing debugging support. mdbcomp/prim_data.m: Add utility functions to allow stm_expand.m to refer to modules in the library. mdbcomp/program_representation.m: Expand the goal_path type to allow the representation of components of atomic goals. compiler/notes/compiler_design.html: Document the new module. compiler/transform_hlds.m: Include the new module in the compiler. compiler/mercury_compile.m: Invoke the STM transformation. compiler/hlds_module.m: Add an auxiliary counter used by the STM transformation. compiler/hlds_pred.m: Add a new predicate origin: the STM transformation. compiler/modules.m: Import the STM builtin module automatically if the module contains any atomic goals. compiler/assertion.m: compiler/bytecode_gen.m: compiler/clause_to_proc.m: compiler/code_gen.m: compiler/code_info.m: compiler/code_util.m: compiler/constraint.m: compiler/cse_detection.m: compiler/deep_profiling.m: compiler/code_util.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/exception_analysis.m: compiler/follow_code.m: compiler/format_call.m: compiler/goal_form.m: compiler/goal_path.m: compiler/goal_util.m: compiler/granularity.m: compiler/hlds_out.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/intermod.m: compiler/lambda.m: compiler/layout_out.m: compiler/lco.m: compiler/lookup_switch.m: compiler/make_hlds_warn.m: compiler/mark_static_terms.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_code_gen.m: compiler/mode_constraint_robdd.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/mode_util.m: compiler/ordering_mode_constraints.m: compiler/pd_cost.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_rep.m: compiler/prog_type.m: compiler/prop_mode_constraints.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_info.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prog.m: compiler/smm_common.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/switch_detection.m: compiler/unused_imports.m: compiler/granularity.m: compiler/granularity.m: Conform to the changes above. Mostly this means handling the new kind of goal. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/build_mode_constraints.m: compiler/closure_analysis.m: compiler/dead_proc_elim.m: compiler/deforest.m: compiler/follow_vars.m: compiler/higher_order.m: compiler/live_vars.m: compiler/liveness.m: compiler/loop_inv.m: compiler/module_qual.m: compiler/prog_util.m: compiler/purity.m: compiler/quantification.m: compiler/store_alloc.m: compiler/stratify.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/trailing_analysis.m: Conform to the changes above. Mostly this means handling the new kind of goal. Switch syntax from clauses to disj. runtime/mercury_stm.[ch]: Implement the primitives needed by the STM transformation. Add more debugging support to the existing primitives. library/term.m: Generalize get_term_context to work on terms of all kinds.	2008-02-27 07:23:57 +00:00
Zoltan Somogyi	9ad83d648d	Convert predicates that used to have one clause for each kind of ... Estimated hours taken: 12 Branches: main compiler/*.m: Convert predicates that used to have one clause for each kind of HLDS goal into explicit disjunctions, since this gives the debugger a meaningful name for each argument. In some cases, this exposed arguments that were used by *no* clause. In other cases, it allowed factoring out common code, as well as code that *should* have been common but wasn't. Put the disjuncts in a meaningful order. In too many cases, they were almost random. Merge the resulting predicates into their parents, in places where the Prolog indexing one could get from separate clauses was the only reason for separating those predicates from their parents in the first place. Similarly, merge child predicates handling generic call kinds and such back into the main predicate where this improves clarity. In some cases, this allows putting the extraction of hlds_goal_expr from a hlds_goal into one place, instead of repeating it in lots of places. Give some predicates more descriptive names. In some cases, rationalize argument order. In some cases, rationalize the order of predicates in the module. Replace some uses of booleans with purpose-specific types. Give some fields names, and put type-identifying prefixes on the names of other fields, to make tag files work better. In some cases, reorder fields to them put into related groups. Use more standard and/or more descriptive variable names Use a standard syntax for if-then-else in each module. Follow our style convention for comments.	2008-01-21 00:32:55 +00:00
Zoltan Somogyi	cc88711d63	Implement true multi-cons_id arm switches, i.e. switches in which we associate ... Estimated hours taken: 40 Branches: main Implement true multi-cons_id arm switches, i.e. switches in which we associate more than one cons_id with a switch arm. Previously, for switches like this: ( X = a, goal1 ; ( X = b ; X = c ), goal2 ) we duplicated goal2. With this diff, goal2 won't be duplicated. We still duplicate goals when that is necessary, i.e. in cases which the inner disjunction contains code other than a functor test on the switched-on var, like this: ( X = a, goal1 ; ( X = b, goalb ; X = c goalc ), goal2 ) For now, true multi-cons_id arm switches are supported only by the LLDS backend. Supporting them on the MLDS backend is trickier, because some MLDS target languages (e.g. Java) don't support the concept at all. So when compiling to MLDS, we still duplicate the goal in switch detection (although we could delay the duplication to just before code generation, if we wanted.) compiler/options.m: Add an internal option that tells switch detection whether to look for multi-cons_id switch arms. compiler/handle_options.m: Set this option based on the back end. Add a version of the "trans" dump level that doesn't print unification details. compiler/hlds_goal.m: Extend the representation of switch cases to allow more than one cons_id for a switch arm. Add a type for representing switches that also includes tag information (for use by the backends). compiler/hlds_data.m: For du types, record whether it is possible to speed up tests for one cons_id (e.g. cons) by testing for the other (nil) and negating the result. Recording this information once is faster than having unify_gen.m trying to compute it from scratch for every single tag test. Add a type for representing a cons_id together with its tag. compiler/hlds_out.m: Print out the cheaper_tag_test information for types, and possibly several cons_ids for each switch arm. Add some utility predicates for describing switch arms in terms of which cons_ids they are for. Replace some booleans with purpose-specific types. Make hlds_out honor is documentation, and not print out detailed information about unifications (e.g. uniqueness and static allocation) unless the right character ('u') is present in the control string. compiler/add_type.m: Fill in the information about cheaper tag tests when adding a du type. compiler/switch_detection.m: Extend the switch detection algorithm to detect multi-cons_id switch arms. When entering a switch arm, update the instmap to reflect that the switched-on variable can now be bound only to the cons_ids that this switch arm is for. We now need to do this, because if the arm contains another switch on the same variable, computing the can_fail field of that switch correctly requires us to know this information. (Obviously, an arm for a single cons_id is unlikely to have switch on the same variable, and for arms for several cons_ids, we previously duplicated the arm and left the unification with the cons_id in each copy, and this unification allowed the correct handling of any later switches. However, the code of a multi-cons_id switch arm obviously cannot have a unification with each cons_id in it, which is why we now need to get the binding information from the switch itself.) Replace some booleans with purpose-specific types, and give some predicates better names. compiler/instmap.m: Provide predicates for recording that a switched-on variable has one of several given cons_ids, for use at the starts of switch arms. Give some predicates better names. compiler/modes.m: Provide predicates for updating the mode_info at the start of a multi-cons_id switch arm. compiler/det_report.m: Handle multi-cons_id switch arms. Update the instmap when entering each switch arm, since this is needed to provide good (i.e. non-misleading) error messages when one switch on a variable exists inside another switch on the same variable. Since updating the instmap requires updating the module_info (since the new inst may require a new entry in an inst table), thread the det_info through as updateable state. Replace some multi-clause predicate definitions with single clauses, to make it easier to print the arguments in mdb. Fix some misleading variable names. compiler/det_analysis.m: Update the instmap when entering each switch arm and thread the det_info through as updateable state, since the predicates we call in det_report.m require this. compiler/det_util.m: Handle multi-cons_id switch arms. Rationalize the argument order of some access predicates. compiler/switch_util.m: Change the parts of this module that deal with string and tag switches to optionally convert each arm to an arbitrary representation of the arm. In the LLDS backend, the conversion process generated code for the arm, and the arm's representation is the label at the start of this code. This way, we can duplicate the label without duplicating the code. Add a new part of this module that associates each cons_id with its tag, and (during the same pass) checks whether all the cons_ids are integers, and if so what are min and max of these integers (needed for dense switches). This scan is needed because the old way of making this test had single-cons_id switch arms as one of its basic assumptions, and doing it while adding tags to each case reduces the number of traversals required. Give better names to some predicates. compiler/switch_case.m: New module to handle the tasks associated with managing multi-cons_id switch arms, including representing them for switch_util.m. compiler/ll_backend.m: Include the new module. compiler/notes/compiler_design.html: Note the new module. compiler/llds.m: Change the computed goto instruction to take a list of maybe labels instead of a list of labels, with any missing labels meaning "not reached". compiler/string_switch.m: compiler/tag_switch.m: Reorganize the way these modules work. We can't generate the code of each arm in place anymore, since it is now possible for more than one cons_id to call for the execution of the same code. Instead, in string_switch.m, we generate the codes of all the arms all at once, and construct the hash index afterwards. (This approach simplifies the code significantly.) In tag switches (unlike string switches), we can get locality benefits if the code testing for a cons_id is close to the code for that cons_id, so we still try to put them next to each other when such a locality benefit is available. In both modules, the new approach uses a utility predicate in switch_case.m to actually generate the code of each switch arm, eliminating several copies the same code in the old versions of these modules. In tag_switch.m, don't create a local label that simply jumps to the code address do_not_reached. Previously, we had to do this for positions in jump tables that corresponded to cons_ids that the switch variable could not be bound to. With the change to llds.m, we now simply generate a "no" instead. compiler/lookup_switch.m: Get the info about int switch limits from our caller; don't compute it here. Give some variables better names. compiler/dense_switch.m: Generate the codes of the cases all at once, then assemble the table, duplicate the labels as needed. This separation of concerns allows significant simplifications. Pack up all the information shared between the predicate that detects whether a dense switch is appropriate and the predicate that actually generates the dense switch. Move some utility predicates to switch_util. compiler/switch_gen.m: Delete the code for tagging cons_ids, since that functionality is now in switch_util.m. The old version of this module could call the code generator to produce (i.e. materialize) the switched-on variable repeatedly. We now produce the variable once, and do the switch on the resulting rval. compiler/unify_gen.m: Use the information about cheaper tag tests in the type constructor's entry in the HLDS type table, instead of trying to recompute it every time. Provide the predicates switch_gen.m now needs to perform tag tests on rvals, as opposed to variables, and against possible more than one cons_id. Allow the caller to provide the tag corresponding to the cons_id(s) in tag tests, since when we are generating code for switches, the required computations have already been done. Factor out some code to make all this possible. Give better names to some predicates. compiler/code_info.m: Provide some utility predicates for the new code in other modules. Give better names to some existing predicates. compiler/hlds_code_util.m: Rationalize the argument order of some predicates. Replace some multi-clause predicate definitions with single clauses, to make it easier to print the arguments in mdb. compiler/accumulator.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/build_mode_constraints.m: compiler/check_typeclass.m: compiler/closure_analysis.m: compiler/code_util.m: compiler/constraint.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/distance_granularity.m: compiler/dupproc.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/exception_analysis.m: compiler/export.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/foreign.m: compiler/format_call.m: compiler/frameopt.m: compiler/goal_form.m: compiler/goal_path.m: compiler/goal_util.m: compiler/granularity.m: compiler/hhf.m: compiler/higher_order.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/inst_check.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lambda.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/livemap.m: compiler/liveness.m: compiler/llds_out.m: compiler/llds_to_x86_64.m: compiler/loop_inv.m: compiler/make_hlds_warn.m: compiler/mark_static_terms.m: compiler/middle_rec.m: compiler/ml_tag_switch.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_util.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pd_cost.m: compiler/pd_into.m: compiler/pd_util.m: compiler/peephole.m: compiler/polymorphism.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/purity.m: compiler/quantification.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_paths.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/store_alloc.m: compiler/stratify.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/trailing_analysis.m: compiler/transform_llds.m: compiler/tupling.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/xml_documentation.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. compiler/ml_string_switch.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. Give some predicates better names. compiler/dependency_graph.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. Change the order of arguments of some predicates to make this easier. compiler/bytecode.m: compiler/bytecode_data.m: compiler/bytecode_gen.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. (The bytecode interpreter has not been updated.) compiler/prog_rep.m: mdbcomp/program_representation.m: Change the byte sequence representation of goals to allow switch arms with more than one cons_id. compiler/prog_rep.m now writes out the updated representation, while mdbcomp/program_representation.m reads in the updated representation. deep_profiler/mdbprof_procrep.m: Conform to the updated program representation. tools/binary: Fix a bug: if the -D option was given, the stage 2 directory wasn't being initialized. Abort if users try to give that option more than once. compiler/Mercury.options: Work around bug #32 in Mantis.	2007-12-30 08:24:23 +00:00
Zoltan Somogyi	168f531867	Add new fields to the goal_info structure for region based memory management. ... Estimated hours taken: 4 Branches: main Add new fields to the goal_info structure for region based memory management. The fields are currently unused, but (a) Quan will add the code to fill them in, and then (b) I will modify the code generator to use the filled in fields. compiler/hlds_goal.m: Make the change described above. Group all the procedures that access goal_info components together. Some of the getters were predicates while some were functions, so this diff changes them all to be functions. (The setters remain predicates.) compiler/*.m: Trivial changes to conform to the change in hlds_goal.m. In simplify.m, break up a huge (800+ line) predicate into smaller pieces.	2007-08-07 07:10:09 +00:00
Zoltan Somogyi	27aaaf412c	Fix the failure of the invalid/modes_erroneous test case, whose symptom was ... Estimated hours taken: 5 Branches: main Fix the failure of the invalid/modes_erroneous test case, whose symptom was an error message about a "mode error in unification of `X' and `X'". The root cause of the problem was that the renaming of head variables computed by headvar_names.m was being applied too early, during typechecking. The fix is to apply it after the frontend (all the passes that can generate error messages). To avoid slowdowns from larger pred_infos, this diff also moves the least frequently used fields of pred_infos to a subterm. (Proc_infos already had a subterm.) This leads to an almost 3% speedup. compiler/headvar_names.m: Store the renaming instead of applying it. compiler/simplify.m: Apply the renaming in invocations after the front end, since doing so may allow some excess assignments to be eliminated. compiler/hlds_pred.m: Add fields to pred_infos and proc_infos for the renaming. Move the least frequently used fields of pred_infos into a pred_sub_info. Some fields of pred_infos were being accessed using predicates that did not follow our naming conventions, and some were accessed using field access functions that are now inappropriate; fix them all. Require the caller to provide the renaming when creating new pred_infos and proc_infos. This is to force the compiler components that do this to propagate the renaming fields of the original predicates and/or procedures to their modified versions. Convert that some old code that used if-then-elses to use switches instead. compiler/hlds_out.m: Write out the new pred_info and proc_info fields. compiler/*.m: Conform to the changes in hlds_pred.m. compiler/hlds_clauses.m: Avoid ambiguity by giving a prefix to the fields of the clauses_info type. tests/invalid/ho_type_mode_bug.err_exp: tests/invalid/merge_ground_any.err_exp: Don't expect error messages about "X = X" anymore.	2007-05-17 03:53:13 +00:00
Zoltan Somogyi	92966551f1	Replace the workaround for the bootstrapping problem with deep profiling grades ... Estimated hours taken: 16 Branches: main Replace the workaround for the bootstrapping problem with deep profiling grades with a proper fix. The fix requires changing the builtin generic unify and compare routines by removing the pretest comparing the two argument words for equality. Since this can alter the algorithmic complexity of the program (for the worse) which a profiler should definitely avoid, we compensate for this by adding the pretest to the compiler-generated unify and compare predicates. Since these pretests are executed even when the deleted pretest wouldn't be, this can also alter algorithmic complexity (for the better) at the cost of higher constant factors. However, the likelyhood of such alteration is much smaller: if the top level of a term doesn't match, chances are most of the function symbols at the lower levels won't match either. In any case, the user has the option of getting this better algorithmic complexity anyway by specifying the new option --should-pretest-equality. However, until we have more experience with it, the documentation of the new option is commented out. runtime/mercury_conf_param.h: Remove the workaround. runtime/mercury_unify_compare_body.h: Remove the problematic pretest, and document the problem that would occur in its presence. Document the user_by_rtti dummy type constructor. Fix some misleading abort messages. compiler/options.m: Add the --should-pretest-equality option. Add (commented out) documentation for another option for which it was missing. doc/user_guide.texi: Add (commented out) documentation for the new option, and for some others which it was missing. compiler/handle_options.m: Make deep profiling imply the need for pretests in compiler generated unify and compare predicates. compiler/unify_proc.m: If the new option is set, add pretests to unify and compare predicates. We have to be careful to make sure that we don't add pretests if they would try to unify two non-ground terms, or if the unification is guaranteed to fail (since the casts in the pretest would obscure this fact). Implementing this required changing the approach of this module. Instead of most predicates generating single clauses, they now generate disjuncts for a disjunction that itself can be put inside the if-then-else whose condition is the pretest. Since these predicates not longer generate clauses, their names have been changed accordingly. compiler/hlds_goal.m: Add a goal feature for marking an if-then-else as representing a pretest. compiler/saved_vars.m: Handle the new goal feature. compiler/goal_util.m: Add a function for stripping pretests away. compiler/post_term_analysis.m: compiler/term_constr_build.m: compiler/term_pass1.m: compiler/term_pass2.m: Strip pretests away before termination analysis, since the analysis can't yet prove termination in the presence of the pretest. compiler/prog_type.m: Add some auxilary predicates, and change the signature of an existing predicate to make it more convenient to use. compiler/type_util.m: Conform to the change in prog_type.m, and in the process fix code to avoid the assumption that the names of standard library modules are unqualified (since the plan is to put them in package "std"). tests/hard_coded/profdeep_seg_fault.{m,exp}: Fix the test case to be more readable and to generate properly line-terminated output, now that we pass it. BUGS: Remove the entry for the bug fixed by this diff.	2007-04-13 04:56:46 +00:00
Zoltan Somogyi	ba93a52fe7	This diff changes a few types from being defined as equivalent to a pair ... Estimated hours taken: 10 Branches: main This diff changes a few types from being defined as equivalent to a pair to being discriminated union types with their own function symbol. This was motivated by an error message (one of many, but the one that broke the camel's back) about "-" being used in an ambiguous manner. It will reduce the number of such messages in the future, and will make compiler data structures easier to inspect in the debugger. The most important type changed by far is hlds_goal, whose function symbol is now "hlds_goal". Second and third in importance are llds.instruction (function symbol "llds_instr") and prog_item.m's item_and_context (function symbol "item_and_context"). There are some others as well. In several places, I rearranged predicates to factor the deconstruction of goals into hlds_goal_expr and hlds_goal_into out of each clause into a single point. In many places, I changed variable names that used "Goal" to refer to just hlds_goal_exprs to use "GoalExpr" instead. I also changed variable names that used "Item" to refer to item_and_contexts to use "ItemAndContext" instead. This should make reading such code less confusing. I renamed some function symbols and predicates to avoid ambiguities. I only made one algorithmic change (at least intentionally). In assertion.m, comparing two goals for equality now ignores goal_infos for all kinds of goals, whereas previously it ignored them for most kinds of goals, but for shorthand goals it was insisting on them being equal. This seemed to me to be a bug. Pete, can you confirm this?	2007-01-06 09:23:59 +00:00
Julien Fischer	b4c3bb1387	Clean up in unused module imports in the Mercury system detected ... Estimated hours taken: 3 Branches: main Clean up in unused module imports in the Mercury system detected by --warn-unused-imports. analysis/*.m: browser/*.m: deep_profiler/*.m: compiler/*.m: library/*.m: mdbcomp/*.m: profiler/*.m: slice/*.m: Remove unused module imports. Fix some minor departures from our coding standards. analysis/Mercury.options: browser/Mercury.options: deep_profiler/Mercury.options: compiler/Mercury.options: library/Mercury.options: mdbcomp/Mercury.options: profiler/Mercury.options: slice/Mercury.options: Set --no-warn-unused-imports for those modules that are used as packages or otherwise break --warn-unused-imports, e.g. because they contain predicates with both foreign and Mercury clauses and some of the imports only depend on the latter.	2006-12-01 15:04:40 +00:00
Peter Ross	f08f22a7de	Generate an XML representation of the du types in the current module. ... Estimated hours taken: 24 Branches: main Generate an XML representation of the du types in the current module. The XML representation contains all the information about the type, as well as associating with each type, data constructor and data field any comments located near the comment. The current strategy associates the comment starting on the same line as the type declaration, and if there is none then the comment directly above. At a later date, this strategy needs to be made more flexible. This required two main changes to the compiler. Change one was to associate with a term.variable the context of that variable. Then the constructor and constructor_arg types had to have their context recorded. compiler/xml_documentation.m: Add a pass that generates an XML documentation for the du types in the current module. compiler/handle_options.m: compiler/mercury_compile.m: compiler/options.m: Call the xml_documentation phase and stop afterwards. compiler/error_utils.m: Add a utitily predicate for reporting errors where a file is unable to be opened. library/term.m: Add the term.context to term.variables. Remove the backwards mode of var_list_to_term_list as it no longer works. Make the predicate version of term_list_to_var_list semidet as we can no longer use the backwards version var_list_to_term_list. NEWS: Mention the changes to the term module. library/parser.m: Fill in the term.context of term.variables while parsing. compiler/prog_data.m: Add the context to the constructor and constructor_arg types. compiler/prog_io.m: Fill in the context fields in the constructor and constructor_arg types. compiler/add_clause.m: compiler/prog_io.m: compiler/prog_io_typeclass.m: compiler/typecheck.m: Call the correct version of term_list_to_var_list, to deal with the fact that we removed the reverse mode of var_list_to_term_list. compiler/notes/compiler_design.html: doc/user_guide.texi: Document the new module. compiler/add_clause.m: compiler/det_util.m: compiler/fact_table.m: compiler/hlds_out.m: compiler/inst_graph.m: compiler/intermod.m: compiler/make_hlds_passes.m: compiler/mercury_to_mercury.m: compiler/prog_ctgc.m: compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: compiler/prog_io_typeclass.m: compiler/prog_io_util.m: compiler/prog_io_util.m: compiler/prog_util.m: compiler/state_var.m: compiler/superhomogeneous.m: compiler/switch_detection.m: compiler/typecheck_errors.m: library/term_io.m: library/varset.m: Handle the context in the term.variable structure. compiler/add_type.m: compiler/check_typeclass.m: compiler/equiv_type.m: compiler/hhf.m: compiler/hlds_out.m: compiler/inst_check.m: compiler/make_tags.m: compiler/mercury_to_mercury.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mode_util.m: compiler/module_qual.m: compiler/post_typecheck.m: compiler/prog_io.m: compiler/prog_mode.m: compiler/prog_type.m: compiler/recompilation.check.m: compiler/recompilation.usage.m: compiler/special_pred.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/unify_proc.m: compiler/untupling.m: compiler/unused_imports.m: Handle the context field in the constructor and constructor_arg types. compiler/check_hlds.m: Add the xml_documentation module.	2006-11-01 06:33:38 +00:00
Zoltan Somogyi	f9cac21e3e	Get rid of a bunch more ambiguities by renaming predicates, mostly ... Estimated hours taken: 8 Branches: main Get rid of a bunch more ambiguities by renaming predicates, mostly in polymorphism.m, {abstract,build,ordering}_mode_constraints.m, prog_type.m, and opt_debug.m in the compiler directory and term_io.m, term.m, parser.m, and string.m in the library. In some cases, when the library and the compiler defined the same predicate with the same code, delete the compiler's copy and give it access to the library's definition by exporting the relevant predicate (in the undocumented part of the library module's interface). NEWS: Mention that the names of some library functions have changed. library/*.m: compiler/*.m: mdbcomp/*.m: browser/*.m: Make the changes mentioned above, and conform to them. test/general/string_test.m: test/hard_coded/string_strip.m: test/hard_coded/string_strip.exp: Conform to the above changes.	2006-09-20 09:42:28 +00:00
Zoltan Somogyi	2b2f3d3cbe	This diff contains no algorithmic changes. ... Estimated hours taken: 8 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch of function symbols to reduce ambiguity. Basically I went through prog_data.m, prog_item.m, hlds_data.m, hlds_goal.m and hlds_pred.m looking for type definitions containing function symbol names that were either language "keywords" (e.g. "terminates", which is an annotation on foreign_procs), used with slightly different meanings in several types (e.g. "sym"), or both (e.g. "call"). When I found such type definitions, I changed the names of the function symbols, usually by adding a prefix or suffix indicating the type to all function symbols of the type. For example, the old function symbol "foreign_proc" in type "pragma_type" is now named "pragma_foreign_proc", and the names of all other function symbols in that type also start with "pragma_". All of this should yield simpler compiler error messages when we make mistakes, and will make it more likely that looking up a function symbol using a tags file will take you to the actual definition of the relevant instance of that function symbol. However, the most important benefit is the increase in the readability of unfamiliar code; the reader won't have to emulate the compiler's type ambiguity resolution algorithm (which in many cases used to require distinguishing between f/14 and f/15 by counting the arguments, e.g. for "pred_or_func"). compiler/prog_data.m: compiler/prog_item.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_pred.m: Rename function symbols as explained above. compiler/*.m: Conform to the function symbol renames. In some cases, rename other function symbols as well. Minor style fixes, e.g. replace if-then-elses with switches, or simple det predicates with functions.	2006-08-20 08:21:36 +00:00
Zoltan Somogyi	a8f63e4d6f	This diff implements step 2 of the fix for a bug I introduced when turning ... Estimated hours taken: 1 Branches: main This diff implements step 2 of the fix for a bug I introduced when turning the primitives involved in implementing trace goals into builtins. The bug is that that builtin primitives have to be declared, but if they don't have definitions, then add_pred *creates* a definition for them which assumes them to be pure. The primitives involved in trace goal implementations are semipure and impure respectively. library/private_builtin.m: Add declarations for trace_get_io_state and trace_set_io_state. The rest of the diff is for fixing the problems that cropped up with termination analysis of these primitives. compiler/type_util.m: Fix the predicate for classifying type constructors to make it recognize dummy types. Also, factor out some code to ensure that data structures are not tested repeatedly against the same pattern. Without this fix, termination analysis was complaining about builtins with non-zero-sized outputs. compiler/term_norm.m: Change the argument order of zero_size_type to conform to our conventions. compiler/term_util.m: compiler/term_constr_util.m: compiler/termination.m: The predicate all_args_input_or_zero_size used to be defined in both term_constr_util and termination.m (with identical code). Replace both with a single definition in term_util. In term_util.m, rename a predicate whose name clashed with a Mercury keyword. compiler/complexity.m: compiler/size_prof.m: compiler/term_constr_build.m: compiler/term_constr_initial.m: Conform to the changes above.	2006-08-16 01:25:48 +00:00
Julien Fischer	aeeedd2c13	Standardize formatting of comments at the beginning of modules. ... compiler/*.m: Standardize formatting of comments at the beginning of modules.	2006-07-31 08:32:11 +00:00
Zoltan Somogyi	9d23d8e2e7	Implement the trace goal construct we discussed, for now for the LLDS backends ... Estimated hours taken: 70 Branches: main Implement the trace goal construct we discussed, for now for the LLDS backends only. Since the syntax of trace goals is non-trivial, useful feedback on syntax errors inside trace goal attributes is essential. With the previous setup, this wasn't possible, since the code that turned terms into parse tree goals turned *all* terms into goals; it couldn't recognize any errors, sweeping them under the rug as calls. This diff changes that. Now, if this code recognizes a keyword that indicates a particular construct, it insists on the rest of the code following the syntax required for that construct, and returns error messages if it doesn't. We handle the trace goal attributes that specify state variables to be threaded through the trace goal (either the I/O state or a mutable variable) in add_clause.m, at the point at which we transform the list of items to the HLDS. We handle the compile-time condition on trace goals in the invocation of simplify at the end of semantics analysis, by eliminating the goal if the compile-time condition isn't met. We handle run-time conditions on trace goals partially in the same invocation of simplify: we transform trace goals with runtime conditions into an if-then-else with the trace goal as the then part and `true' as the else part, the condition being a foreign_proc that is handled specially by the code generator, that special handling being to replace the actual code of the foreign_proc (which is a dummy) with the evaluation of the runtime condition. Since these changes require significant changes to some of our key data structures, I took the liberty of doing some renaming of function symbols at the same time to avoid using ambiguities with respect to language keywords. library/ops.m: Add "trace" as an operator. compiler/prog_data.m: Define data types to represent the various attributes of trace goals. Rename some function symbols to avoid ambiguities. compiler/prog_item.m: Extend the parse tree representation of goals with a trace goal. compiler/mercury_to_mercury.m: Output the new kind of goal and its components. compiler/hlds_goal.m: Extend the HLDS representation of scopes with a scope_reason representing trace goals. Add a mechanism (an extra argument in foreign_procs) to allow the representation of goals that evaluate runtime trace conditions. Since this requires modifying all code that traverses the HLDS, do some renames that were long overdue: rename not as negation, rename call as plain_call, and rename foreign_proc as call_foreign_proc. These renames all avoid using language keywords as function symbols. Change the way we record goals' purities. Instead of optional features to indicate impure or semipure, which is error-prone, use a plain field in the goal_info, accessed in the usual way. Add a way to represent that a goal contains a trace goal, and should therefore be treated as if it were impure when considering whether to optimize it away. Reformat some comments describing function symbols. compiler/hlds_out.m: Output the new construct in the HLDS. compiler/prog_io_util.m: Generalize the maybe[123] types to allow the representation of more than one error message. Add functions to extract the error messages. Add a maybe4 type. Rename the function symbols of these types to avoid massive ambiguity. Change the order of some predicates to bring related predicates next to each other. compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: Rework these modules almost completely to find and accumulate syntax errors as terms are being parsed. In some cases, this allowed us to replace "XXX this is a hack" markers with meaningful error-reporting code. In prog_io_goal.m, add code for parsing trace goals. In a bunch of places, update obsolete coding practices, such as using nested chains of closures instead of simple sequential code, and using A0 and A to refer to values of different types (terms and goals respectively). Use more meaningful variable names. Break up some too-large predicates. compiler/superhomogeneous.m: Find and accumulate syntax errors as terms are being parsed. compiler/add_clause.m: Add code to transform trace goals from the parse tree to the HLDS. This is where the IO state and mutable variable attributes of trace goals are handled. Eliminate the practice of using the naming scheme Body0 and Body to refer to values of different types (prog_item.goal and hlds_goal respectively). Use error_util for some error messages. library/private_builtin.m: Add the predicates referred to by the transformation in add_clause.m. compiler/goal_util.m: Rename a predicate to avoid ambiguity. compiler/typecheck.m: Do not print error messages about missing clauses if some errors have been detected previously. compiler/purity.m: Instead of just computing purity, compute (and record) also whether a goal contains a trace goal. However, treat trace goals as pure. compiler/mode_info.m: Add trace goals as a reason for locking variables. Rename some function symbols to avoid ambiguity. compiler/modes.m: When analyzing trace goal scopes, lock the scope's nonlocal variables to prevent them from being further instantiated. compiler/det_analysis.m: Insist on the code in trace goal scopes being det or cc_multi. compiler/det_report.m: Generate the error message if the code in a trace goal scope isn't det or cc_multi. compiler/simplify.m: At the end of the front end, eliminate trace goal scopes if their compile-time condition is false. Transform trace goals with runtime conditions as described at the top. Treat goals that contain trace goals as if they were impure when considering whether to optimize them away. compiler/mercury_compile.m: Tell simplify when it is being invoked at the end of the front end. Rename a predicate to avoid ambiguity. compiler/trace_params.m: Provide the predicates simplify.m need to be able to evaluate the trace goal conditions regarding trace levels. compiler/trace.m: compiler/trace_gen.m: Rename the trace module as trace_gen, since "trace" is now an operator. Rename some predicates exported by the module, now that it is no longer possible to preface calls with "trace." as a module qualifier. compiler/notes/compiler_design.html: Document this name change. compiler/options.m: Rename the trace option as trace_level internally, since "trace" is now an operator. The user-visible name remains the same. Add the new --trace-flag option. Delete an obsolete option. compiler/handle_options.m: Rename the function symbols of the grade_component type, since "trace" is now an operator. compiler/llds.m: Extend the LLDS with a mechanism to refer to C global variables. For now, these are used to refer to C globals that will be created by mkinit to represent the initial values of the environment variables referred to by trace goals. compiler/commit_gen.m: Check that no trace goal with a runtime condition survives to code generation; they should have been transformed by simplify.m. compiler/code_gen.m: Tell commit_gen.m what kind of scope it is generating code for. compiler/pragma_c_gen.m: Generate code for runtime conditions when handling the foreign_procs created by simplify.m. compiler/code_info.m: Allow pragma_c_gen.m to record what environment variables it has generated references to. compiler/proc_gen.m: Record the set of environment variables a procedure refers to in the LLDS procedure header, for efficient access by llds_out.m. compiler/llds_out.m: Handle the new LLDS construct, and tell mkinit which environment variables need C globals created for them. compiler/pd_util.m: Rename some predicates to avoid ambiguity. compiler/*.m: Conform to the changes above, mainly the renames of function symbols and predicates, the changed signatures of some predicates, and the new handling of purity. util/mkinit.c: Generate the definitions and the initializations of any C globals representing the initial status (set or not set) of environment variables needed by trace goals. library/assoc_list.m: Add some predicates that are useful in prog_io*.m. library/term_io.m: Minor cleanup. tests/hard_coded/trace_goal_{1,2}.{m,exp}: New test cases to test the new construct, identical except for whether the trace goal is enabled at compile time. tests/hard_coded/trace_goal_env_{1,2}.{m,exp}: New test cases to test the new construct, identical except for whether the trace goal is enabled at run time. tests/hard_coded/Mercury.options: tests/hard_coded/Mmakefile: Enable the new test cases. tests/invalid/*.err_exp: Update the expected output for the new versions of the error messages now being generated.	2006-07-27 05:03:54 +00:00
Julien Fischer	459847a064	Move the univ, maybe, pair and unit types from std_util into their own ... Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.	2006-03-29 08:09:58 +00:00
Zoltan Somogyi	25b8b1abc3	Fix several performance bugs that showed up when the compiler was invoked on ... Estimated hours taken: 20 Branches: main Fix several performance bugs that showed up when the compiler was invoked on Douglas Auclair's training_cars example. Also fix some minor problems that made it harder to find the information needed to localize those problems. training_cars.m is hard to compile quickly because it is big in two dimensions: it has lots of clauses, and each clause has big terms. My laptop still tries to swap itself to death on the full version of training_cars.m (it has only 512 Mb), but the compiler now works fine on a version containing about 20% of its clauses, whereas previously it couldn't compile it at all. In most cases, the changes convert N^2 algorithms to NlogN algorithms. They probably have higher constant factors and may yield small slowdowns for small N, but this is probably not noticeable. Avoiding bad worst case behavior is more important. compiler/superhomogeneous.m: Record the number of goals inserted in each goal being converted to superhomogeneous form. If this exceeds a threshold, wrap a from_ground_term scope around it. Put the predicates into a more cohesive sequence. compiler/field_access.m: Work with the code in superhomogeneous to record the number of inserted goals. Reorder the arguments of some performances to be consistent with the predicates in superhomogeneous.m. compiler/modes.m: Use the from_ground_term scope to reverse the list of inserted unifications if necessary. It is much more efficient to do this here than to let it happen by sequences of delays and wakeups. That would have quadratic complexity; this is linear. This is what I originally introduced from_ground_term scopes for. Then, the overhead was too high, because I added one scope per function symbol. This version should be fine, since there is at most one scope added per argument of an atom (clause head or call). compiler/modes.m: compiler/unique_modes.m: When we are processing goals inside a from_ground_term scope, record this fact. compiler/mode_info.m: Make it possible to record this fact. compiler/modecheck_unify.m: When we are inside a from_ground_term scope, don't try to update the insts of vars on the right hand sides of construction unifications. Since these variables came from expansion to superhomogeneous form, those variables won't occur in any following code, so updating their state is useless, and the algorithm we used to do so is linear in the size of the inst. Since the size of an inst of a variable that results from superhomogeneous expansion is itself on average proportional to the size of the original term, this change turns a quadratic algorithm into a linear one. compiler/inst_match.m: Use balanced trees instead of ordered lists to represents sets of expansions, since these sets can be large. Note an opportunity for further improvement. compiler/inst_util.m: Note another opportunity for further improvement. compiler/instmap.m: Rename several predicates to avoid ambiguities. compiler/cse_detection.m: We used to print statistics for the processing of each procedure without saying which procedure it is for; fix this. compiler/switch_detection.m: Don't print progress messages for predicates with no procedures, since they would be misleading. compiler/higher_order.m: Change an algorithm that was quadratic in the number of arms for merging the information from the different arms of disjunctions and switches to an NlogN algorithm. Change the algorithm for merging the info from two branches that quadratic in the number of variables per arm to an NlogN algorithm. Changed some type equivalences to notag types to aid robustness. compiler/quantification.m: Rename several predicates to avoid ambiguities. The sets of variables in different arms of disjunctions and switches tend to have relatively small intersections. Yet the algorithms we used to compute the set of variables free in the disjunction or switch included the variables from the already processed arms in the sets being accumulated when processing later arms, leading to the quadratic behavior. This diff changes the algorithm to process each arm independently, and then use a more balanced algorithm to summarize the result. Specialize the predicates that compute sets of free vars in various HLDS fragments to work either with ordinary_nonlocals or code_gen_nonlocals without making the same decision repeatedly. Move some code out of large predicates into predicates of their own. compiler/Mercury.options: Specify the compiler option that can exploit this specialization to make the code run faster. compiler/simplify.m: Use a more efficient data structure for recording the parameters of an invocation of simplification. Change some predicate names and function symbol names to avoid ambiguity. compiler/common.m: compiler/deforest.m: compiler/deforest.m: compiler/make_hlds_warn.m: compiler/mercury_compile.m: compiler/pd_util.m: compiler/stack_opt.m: compiler/term_constr_build.m: Conform to the changes in simplify.m and/or instmap.m. compiler/mercury_compile.m: Fix a bug in progress messages for polymorphism.m. compiler/equiv_type_hlds.m: Most of the time, substitutions inside insts have no effect, because very few insts include any reference to a types. Instead of the old approach of building new insts and then throwing them away if they are the same as the old ones, don't build new insts at all if the old inst contains no types. compiler/common.m: Change some predicate names to make them clearer. compiler/hlds_clauses.m: Record the number of clauses so far, to allow a more informative progress message to be printed. compiler/add_clause.m: Print this more informative progress message. Conform to the changes in superhomogeneous.m. compiler/code_gen.m: Use the context of the predicate's first clause (which will be the context of the first clause head) as the context of the predicate's interface events. Unlike the context of the body goal, this won't be affected by program transformations such as wrapping a from_ground_term scope around some goals. It is better for users anyway, since the old policy lead to contexts in the middle of procedure bodies if the top level goal was a disjunction, switch or if-then-else. tests/debugger/*.exp: Update the expected outputs to conform to the change to code_gen.m.	2006-03-29 00:57:46 +00:00
Zoltan Somogyi	12deb40264	Rename all the get access predicates in these modules that don't ... Estimated hours taken: 0.1 Branches: main compiler/hlds_clauses.m: compiler/hlds_pred.m: Rename all the get access predicates in these modules that don't already have put "get" in their name. (The names of the set access predicates were OK already.) compiler/*.m: Conform to the above. All this was done by this sed script: s/clauses_info_varset/clauses_info_get_varset/ s/clauses_info_explicit_vartypes/clauses_info_get_explicit_vartypes/ s/clauses_info_vartypes/clauses_info_get_vartypes/ s/clauses_info_headvars/clauses_info_get_headvars/ s/clauses_info_clauses_rep/clauses_info_get_clauses_rep/ s/clauses_info_rtti_varmaps/clauses_info_get_rtti_varmaps/ s/pred_info_import_status/pred_info_get_import_status/ s/pred_info_arg_types/pred_info_get_arg_types/ s/pred_info_typevarset/pred_info_get_typevarset/ s/pred_info_tvar_kinds/pred_info_get_tvar_kinds/ s/pred_info_procedures/pred_info_get_procedures/ s/proc_info_context/proc_info_get_context/ s/proc_info_varset/proc_info_get_varset/ s/proc_info_vartypes/proc_info_get_vartypes/ s/proc_info_headvars/proc_info_get_headvars/ s/proc_info_inst_varset/proc_info_get_inst_varset/ s/proc_info_maybe_declared_argmodes/proc_info_get_maybe_declared_argmodes/ s/proc_info_argmodes/proc_info_get_argmodes/ s/proc_info_maybe_arglives/proc_info_get_maybe_arglives/ s/proc_info_declared_determinism/proc_info_get_declared_determinism/ s/proc_info_inferred_determinism/proc_info_get_inferred_determinism/ s/proc_info_goal/proc_info_get_goal/ s/proc_info_can_process/proc_info_get_can_process/ s/proc_info_rtti_varmaps/proc_info_get_rtti_varmaps/ s/proc_info_eval_method/proc_info_get_eval_method/ s/proc_info_is_address_taken/proc_info_get_is_address_taken/ s/proc_info_stack_slots/proc_info_get_stack_slots/ s/proc_info_liveness_info/proc_info_get_liveness_info/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/	2006-03-27 09:36:34 +00:00
Zoltan Somogyi	5b8f96f61d	Prepare for an extension of promise_equivalent_solutions that will allow us ... Estimated hours taken: 5 Branches: main Prepare for an extension of promise_equivalent_solutions that will allow us to better handle values of user-defined types. The problem is that currently, the deconstruction of a value of such a type can be followed only by code that cannot fail, otherwise the cc_multi deconstruction is not in the required single-solution context. If the following code is naturally semidet, this can be worked around by turning it into det code returning a maybe and testing the maybe outside the promise_equivalent_solutions, but this is inefficient, and in any case it does not generalize to nondet code without even more horrendous inefficiency and inconvenience. (You have to create a nondet closure and call it outside the promise_equivalent_solutions.) The solution I came up with is something is to have a construct that contains - a list of deconstructions on types with user-defined equality, - a goal, and - the list of outputs of that goal. The idea is that this would be transformed into a conjunction of the first and second items, and wrapped inside a special kind of conj that provides a scope for the implicit promise, which is that the set of solutions of the goal in the second item doesn't depend on what concrete terms the deconstructions in the first item return out of the set of concrete terms they *could* return. The deconstructions in the first item would be marked to tell determinism analysis to effectively ignore the fact that they involve user-defined equality. The actual addition of that construct is left for a future change, after we agree on the syntax. compiler/hlds_goal.m: Generalize the existing promise_equivalent_solutions scope to a promise_solutions scope with a flag that says whether in the source code it was originally the existing "promise_equivalent_solutions" construct or the new construct (which doesn't exist yet, but is indicated by the symbol "same_solutions" for now). Replace the conj and par_conj hlds_goal_exprs with a single goal expression: conj with an additional argument which is either plain_conj or parallel_conj. This was part of an earlier design in which a third kind of disjunction took the role now assigned to the new kind of promise_solutions scope, but turned out to be a good idea anyway, since in many places the compiler does treat the two kinds of conjunctions the same. This part of the change is responsible for the fact that this change results in a net *reduction* of about 40 lines. Move the most frequently used kinds of goal expressions to the front of the type declaration to allow the compiler to make better decisions about tag allocation. Add the goal marker we will add to the deconstructions in the first item. Replace the true_goal and fail_goal predicates with functions to make them easier to use, and rename their variants that take a context argument to avoid unnecessary ambiguity. compiler/*.m: Conform to the change in hlds_goal.m. Misc changes to make code more robust, e.g. replacing semidet predicates on goal expressions with functions returning bool. Misc cleanups, e.g. removal of unnecessary module qualifications that made lines too long, renaming predicates whose names include "disj" if they are also used to process parallel conjunctions (since in both parallel conjunctions and in disjunctions the goals are independent), and turning semidet predicates that switch on goal expressions into bool functions (to make similar changes more rebust in the future).	2006-02-24 05:49:43 +00:00
Julien Fischer	45fdb6c451	Use expect/3 in place of require/2 throughout most of the ... Estimated hours taken: 4 Branches: main compiler/*.m: Use expect/3 in place of require/2 throughout most of the compiler. Use unexpected/2 (or sorry/2) in place of error/1 in more places. Fix more dodgy assertion error messages. s/map(prog_var, mer_type)/vartypes/ where the latter is meant.	2005-11-28 04:11:59 +00:00
Zoltan Somogyi	f9fe8dcf61	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 8 Branches: main Improve the error messages generated for determinism errors involving committed choice contexts. Previously, we printed a message to the effect that e.g. a cc pred is called in context that requires all solutions, but we didn't say *why* the context requires all solutions. We now keep track of all the goals to the right that could fail, since it is these goals that may reject the first solution of a committed choice goal. The motivation for this diff was the fact that I found that locating the failing goal can be very difficult if the conjunction to the right is a couple of hundred lines long. This would have been a nontrivial problem, since (a) unifications involving values of user-defined types are committed choice goals, and (b) we can expect uses of user-defined types to increase. compiler/det_analysis.m: Keep track of goals to the right of the current goal that could fail, and include them in the error representation if required. compiler/det_report.m: Include the list of failing goals to the right in the representations of determinism errors involving committed committed choice goals. Convert the last part of this module that wasn't using error_util to use error_util. Make most parts of this module just construct error message specifications; print those specifications (using error_util) in only a few places. compiler/hlds_out.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: compiler/compiler_util.m: Error_util is still changing reasonably often, and yet it is included in lots of modules, most of which need only a few simple non-parse-tree-related predicates from it (e.g. unexpected). Move those predicates to a new module, compiler_util.m. This also eliminates some undesirable dependencies from libs to parse_tree. compiler/libs.m: Include compiler_util.m. compiler/notes/compiler_design.html: Document compiler_util.m, and fix the documentation of some other modules. compiler/*.m: Import compiler_util instead of or in addition to error_util. To make this easier, consistently use . instead of __ for module qualifying module names. tests/invalid/det_errors_cc.{m,err_exp}: Add this new test case to test the error messages for cc contexts. tests/invalid/det_errors_deet.{m,err_exp}: Add this new test case to test the error messages for unifications inside function symbols. tests/invalid/Mmakefile: Add the new test cases. tests/invalid/det_errors.err_exp: tests/invalid/magicbox.err_exp: Change the expected output to conform to the change in det_report.m, which is now more consistent.	2005-10-28 02:11:03 +00:00
Julien Fischer	c5e315b0fc	Add the first part of the new termination analyser. ... Estimated hours taken: lots Branches: main Add the first part of the new termination analyser. This includes most of the argument size analyser and a simple termination checker - I'll add a more extensive one as part of another diff. The one included here is only a placeholder and is roughly equivalent to the one used by the existing termination analyser. The new analysis abstracts term size relationships over a domain of (rational) convex constraints. The resulting size relationships are, in many cases, more precise than we can obtain with the old analysis. This means that we should be able to prove termination in more cases. The tradeoff for this increased precision is that the new termination analysis is slower than the old one. We should also be able to adapt the new analyser to handle things like higher-order constructs and intermodule mutual recursion more easily than the old one. The code for writing termination2_info pragmas to .opt and .trans_opt files is currently commented out. It will need to stay that way until after this change bootstraps and after the tests/term directory as been reworked (the .trans_opt_exp files need to updated and some new test cases have to added - I'll do this as part of separate diff). It isn't clear what the relationship between the new analyser and the existing one should be, so at the moment they are as independent of each other as possible. compiler/termination2.m: New file. Invokes the the other passes of the new analysis and handles the output of termination2_info pragmas to .opt and .trans_opt files. XXX I've disabled the writing out of termination2_info pragmas to the (transitive-)intermodule optimization files until I've updated the test suite. compiler/term_constr_data.m: New file. Defines the main data structures used by the new analysis. compiler/term_constr_initial.m: New file. Sets up information for builtin and compiler generated procedures and processes information about imported procedures. Also handles termination pragmas. compiler/term_constr_build.m: New file. Converts the HLDS representation of a procedure into the abstract representation that we use during the rest of the analysis. compiler/term_constr_fixpoint.m: New file. Perform a fixpoint calculation in order to derive interargument size relationships for a procedure (in the form of convex constraints). compiler/term_constr_pass2.m: New file. A rudimentary termination checker that is roughly equivalent to what the existing termination analysis does. This is just a placeholder. compiler/term_constr_util.m: New file. Utility predicates that are used by the above modules. compiler/term_constr_errors.m: New file. Equivalent to term_errors.m for the new analyser. compiler/rat.m: Provide rational numbers over fixed precision integers. Originally committed on the termination2 branch. compiler/lp_rational.m: Provides the necessary machinery for manipulating systems of linear constraints. Originally committed on the termination2 branch although most of this version is new. (Some bits of the version on the termination2 branch are now in polyhedron.m). The linear solver is essentially the one that is currently in lp.m converted to use rationals rather than floats. compiler/polyhedron.m: New file. An ADT that provides convex polyhedra over the rationals (or at least over rats). The abstraction barrier was designed so that we could experiment with different representations for the polyhedra. compiler/term_norm: Clean up the documentation of this module. Make set_functor_info into a function. Add a function for finding a lower bound on the weight of a functor. compiler/trans_opt.m: Output termination2_info pragmas in .trans_opt files. compiler/transform_hlds.m: Include the new termination analyser. compiler/goal_form.m: When checking whether a goal can loop or not use information from the new termination analyser as well as the old one. compiler/globals.m: compiler/handle_options: compiler/options.m: Add options to control the new analyser. The documentation is currently commented out because the new analysis is still a work-in-progress. It should be uncommented when the new analysis is more mature. XXX The user guide still needs to be updated. compiler/hlds_out.m: Add hlds_out.write_pred_proc_id/4. compiler/hlds_pred.m: Add a slot in the proc_sub_info structure for the termination2_info structure. compiler/rat.m: Provide rational numbers over fixed precision integers. compiler/lp_rational.m: Provide the constraint machinery required by the analyser. compiler/make_hlds.m: Handle imports of termination2_info pragmas. compiler/mercury_compile.m: Run the new pass. Currently, we do this directly after the old termination analysis pass. compiler/mercury_to_mercury.m: Add code to output termination2_info pragmas. compiler/libs.m: Include the rat, polyhedron and lp_rational modules. compiler/prog_data.m: Define the types necessary for termination2_info pragmas. Change the cannot_loop constructor of the generic_termination_info type so it has a polymorphic argument. The new analyser stores information in it. Fix some spelling errors in some of the comments compiler/prog_io_pragma.m: Parse termination2_info pragmas. compiler/error_util.m: Add function versions of sorry/2 and unexpected/2. compiler/module_qual.m: compiler/modules.m: compiler/recompilation.version.m: compiler/termination.m compiler/term_pass2.m compiler/term_util.m: Minor changes to confrom to the above.	2005-04-07 06:32:17 +00:00