12 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	be5b71861b	Convert almost all the compiler modules to use . instead of __ as ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all the compiler modules to use . instead of __ as the module qualifier. In some cases, change the names of predicates and types to make them meaningful without the module qualifier. In particular, most of the types that used to be referred to with an "mlds__" prefix have been changed to have a "mlds_" prefix instead of changing the prefix to "mlds.". There are no algorithmic changes.	2006-03-17 01:40:46 +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
Zoltan Somogyi	4d377aba26	Fix a bug reported by Greg Duck. The bug was that the compiler always generated ... Estimated hours taken: 5 Branches: main Fix a bug reported by Greg Duck. The bug was that the compiler always generated a global variable of type MR_Word for each mutable, but could then assign variables of other types to and from this global. If this other type is float, the assignments discard the fractional part. If this other type is something else, the result can be even worse. There are two ways to fix this discrepancy. One is to change the type of the global, and the other is to change the type of the variables it is assigned to and from. The former looks cleaner, but it would mean that every call to the get predicate would require a boxing operation, and that can be relatively slow, since (e.g. for floats) it may require allocating a heap cell. This diff implements both solutions. We use the second solution on the LLDS backend because of its better performance. We have to use the first solution on the MLDS backend, because on that backend the type of the mutable variable is reflected in the signature of the getter and setter predicates (whereas on the LLDS backend all arguments are always MR_Words). compiler/options.m: Add an internal-only option that controls whether we use the first solution or the second. compiler/handle_options.m: Make the MLDS backend imply the first solution. compiler/prog_data.m: For each argument of a foreign_proc item, record whether we want to keep it boxed in the foreign code. Add a foreign_proc attribute that asks for every arg to be kept boxed. We can attach this to the mutable implementation foreign_procs we write out to .opt files. This attribute is deliberately undocumented since users should never use it. compiler/make_hlds_passes.m: For each argument of the get and set foreign_procs we create for mutables, record that we do want to keep it boxed. Move the action of creating the foreign code for the mutable's declaration and definition to the third pass, since during the second pass we don't necessarily know yet what its foreign type is (we may not have processed a foreign_type declaration affecting it). Move the code for creating the foreign code here from prog_mutable, since it depends on the HLDS (and prog_mutable.m is in the parse_tree package). Hoist some error handling code to put it where it belongs, and to avoid some errors being reported twice. compiler/hlds_goal.m: For each argument of a foreign_proc goal, record whether we want to keep it boxed in the foreign code. compiler/llds_out.m: compiler/pragma_c_gen.m: compiler/ml_code_gen.m: compiler/ml_call_gen.m: If a foreign_proc argument is noted as being kept boxed in the foreign_proc code, then keep it that way. compiler/prog_io_pragma.m: Parse the new foreign_proc annotation. compiler/simplify.m: If a foreign_proc has the always_boxed annotation, attach this info to each of its args. We do this here because simplify is guaranteed to be executed before all the code that may inspect these arguments. Since nothing ever deletes an always_boxed annotation of a foreign_proc arg, the code that attaches the annotation is idempotent, so the fact that the compiler executes simplify twice is not a problem. compiler/*.m: Minor changes to conform to the changes in data structures above. compiler/prog_type.m: Move a function definition from prog_mutable to prog_type, and fix the lack of abstraction in its code. compiler/prog_mutable.m: Delete the code moved to make_hlds_passes.m and prog_type.m. compiler/notes/compiler_design.html: Make the documentation of prog_mutable.m easier to read in source. tests/hard_coded/float_gv.{m,exp}: An extended version of Greg's code as a new test case. tests/hard_coded/Mmakefile: Enable the new test case. tests/hard_coded/sub-modules/non_word_mutable.{m,exp}: tests/hard_coded/sub-modules/non_word_mutable.child.m: A version of the float_gv test case in which the compiler-generated get and set foreign_procs should end up in .opt files. tests/hard_coded/sub-modules/Mmakefile: tests/hard_coded/sub-modules/Mercury_options: Enable the new test case, and make it execute with intermodule optimization. tests/invalid/bad_mutable.err_exp: Expect the new output (in which an error is reported just once, not twice).	2006-02-24 01:42:19 +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
Julien Fischer	5f589e98fb	Various cleanups for the modules in the compiler directory. ... Estimated hours taken: 4 Branches: main Various cleanups for the modules in the compiler directory. The are no changes to algorithms except the replacement of some if-then-elses that would naturally be switches with switches and the replacement of most of the calls to error/1. compiler/*.m: Convert calls to error/1 to calls to unexpected/2 or sorry/2 as appropriate throughout most or the compiler. Fix inaccurate assertion failure messages, e.g. identifying the assertion failure as taking place in the wrong module. Add :- end_module declarations. Fix formatting problems and bring the positioning of comments into line with our current coding standards. Fix some overlong lines. Convert some more modules to 4-space indentation. Fix some spots where previous conversions to 4-space indentation have stuffed the formatting of the code up. Fix a bunch of typos in comments. Use state variables in more places; use library predicates from the sv* modules where appropriate. Delete unnecessary and duplicate module imports. Misc. other small cleanups.	2005-11-17 15:57:34 +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
Zoltan Somogyi	b2012c0c0e	Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' ... Estimated hours taken: 8 Branches: main compiler/*.m: Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' and 'mer_mode'. This is to avoid the need to parenthesize these type names in some contexts, and to prepare for the possibility of a parser that considers those words to be reserved words. Rename some other uses of those names (e.g. as item types in recompilation.m). Delete some redundant synonyms (prog_type, mercury_type) for mer_type. Change some type names (e.g. mlds__type) and predicate names (e.g. deforest__goal) to make them unique even without module qualification. Rename the function symbols (e.g. pure, &) that need to be renamed to avoid the need to parenthesize them. Make their replacement names more expressive. Convert some more modules to four space indentation. Avoid excessively long lines, such as those resulting from the automatic substitution of 'mer_type' for 'type'.	2005-10-24 04:14:34 +00:00
Zoltan Somogyi	b54ab42d70	A simple tool for performing substitutions on the source files of the ... Estimated hours taken: 0.5 Branches: main tools/subst: A simple tool for performing substitutions on the source files of the compiler. compiler/*.m: Change the names of the get predicates operating on module_infos to include "get" in the name, for uniformity. This was done mostly by the following sed script, with some manual cleanup afterwards to reduce excessive line lengths. s/module_info_types/module_info_get_type_table/ s/module_info_set_types/module_info_set_type_table/ s/module_info_insts/module_info_get_inst_table/ s/module_info_set_insts/module_info_set_inst_table/ s/module_info_modes/module_info_get_mode_table/ s/module_info_set_modes/module_info_set_mode_table/ s/module_info_ctors/module_info_get_cons_table/ s/module_info_set_ctors/module_info_set_cons_table/ s/module_info_classes/module_info_get_class_table/ s/module_info_set_classes/module_info_set_class_table/ s/module_info_instances/module_info_get_instance_table/ s/module_info_set_instances/module_info_set_instance_table/ s/module_info_superclasses/module_info_get_superclass_table/ s/module_info_set_superclasses/module_info_set_superclass_table/ s/module_info_assertion_table/module_info_get_assertion_table/ s/module_info_exclusive_table/module_info_get_exclusive_table/ s/module_info_ctor_field_table/module_info_get_ctor_field_table/ s/module_info_name/module_info_get_name/ s/module_info_globals/module_info_get_globals/ s/module_info_contains_foreign_types/module_info_get_contains_foreign_types/ s/module_info_num_errors/module_info_get_num_errors/ s/module_info_type_ctor_gen_infos/module_info_get_type_ctor_gen_infos/ s/module_info_stratified_preds/module_info_get_stratified_preds/ s/module_info_unused_arg_info/module_info_get_unused_arg_info/ s/module_info_exception_info/module_info_get_exception_info/ s/module_info_type_spec_info/module_info_get_type_spec_info/ s/module_info_no_tag_types/module_info_get_no_tag_types/ s/module_info_analysis_info/module_info_get_analysis_info/ s/module_info_aditi_top_down_procs/module_info_get_aditi_top_down_procs/	2005-09-30 08:08:49 +00:00
Zoltan Somogyi	6df9a05856	This diff cleans up a bunch of modules. It has no algorithmic changes ... Estimated hours taken: 10 Branches: main This diff cleans up a bunch of modules. It has no algorithmic changes other than in the formatting of error messages. compiler/error_util.m: Delete the obsolete predicate append_punctuation, since the suffix format component can now do more, and do it more easily. compiler/goal_util.m: compiler/hlds_goal.m: compiler/hlds_llds.m: compiler/instmap.m: compiler/const_prop.m: Change the argument order of some the predicates exported by these modules to make them easier to use with state variable syntax. compiler/*.m: Convert a bunch of these modules to four space indentation, and fix departures from our coding style. Conform to the changed argument order above. Use suffixes instead of append_punctuation. library/string.m: Add string.foldl2. tests/invalid/circ_*.err_exp: tests/warnings/unused_args_*.exp: Expect the updated error messages, which format sym_names consistently the same way as other messages.	2005-08-30 04:12:17 +00:00
Zoltan Somogyi	c0607822b2	Complete the first draft of the program transformation for the own minimal ... Estimated hours taken: 12 Branches: main Complete the first draft of the program transformation for the own minimal model of minimal model evaluation. The runtime system is still very incomplete. Nothing in this diff changes anything related to non-mmos grades. compiler/table_gen.m: Change the implementation of the own stack transformation from the previous rough sketch to this first draft. It still uses calls to library predicates instead of inlined foreign_procs in some places, but that will be fixed later. Generalize the infrastructure for handling arguments to associate the position and mode with each argument variable, since this is needed for mechanism the own stack transformation uses to transfer the input arguments from the consumer to the generator. Switch to four-space indentation to avoid a bunch of bad line breaks. Conform to the current style for comments. compiler/complexity.m: Rename some predicates to avoid clashes with similarly named predicates in table_gen.m in the tags file. library/table_builtin.m: Add the library predicates the new tabling transformation needs to hang foreign_procs on. Comment out C code fragments that refer to as-yet-nonexistent C macros or functions, to allow the compiler to link in mmos grades. The predicates in which this happens aren't used yet. Conform to the current style for comments. runtime/mercury_conf_param.h: Document the minimal model tabling's requirement for gc that doesn't recover memory on backtracking. runtime/mercury_mm_own_stacks.[ch]: Revise the mechanism for creating new generators, and add an outline of its implementation. Comment out code that doesn't compile yet. Add the globals we need for communicating the input arguments and the location of the generator structure from the consumer to the newly created generator. runtime/mercury_tabling.h: Fix a bug: the table tip node is a generator, not a consumer. runtime/mercury_tabling_preds.h: Replace the previous placeholder definitions of some macros with drafts of actual definitions. runtime/mercury_context.h: Conform to the current style for comments. Switch to four-space indentation to avoid a bunch of bad line breaks. trace/mercury_trace_internal.c: Conform to the change in mercury_tabling.h.	2005-06-03 07:04:33 +00:00
Zoltan Somogyi	c08ca7fbc8	Import only one module per line in the modules of the compiler ... Estimated hours taken: 3 Branches: main compiler/*.m: Import only one module per line in the modules of the compiler where my previous diff did not already do so. Misc other cleanups. Where relevant, use the new mechanism in tree.m. compiler/tree.m: Fix a performance problem I noticed while update :- import_module items. Instead of supplying a function to convert lists of trees to a tree, make the tree data structure able to hold a list of subtrees directly. This reduces the number of times where we have to convert list of trees to trees that are sticks just to stay within the old definition of what a tree is.	2005-03-24 02:00:43 +00:00
Zoltan Somogyi	86ac840326	Implement a mechanism to generate the information required to determine the ... Estimated hours taken: weeks Branches: main Implement a mechanism to generate the information required to determine the algorithmic complexity of selected procedures. The basis of the mechanism is a program transformation that wraps up the body of each selected procedure in code that detects top-level (non-recursive) calls, and for each top-level call, records the sizes of the input arguments and information about the cost of the call. For now, the cost information consists only of the number of cells and words allocated during the call, but there is provision for later adding information from a real-time clock. compiler/complexity.m: A new module containing the new transformation. compiler/transform_hlds.m: Add complexity.m to the list of submodules. compiler/mercury_compile.m: Invoke the new module. compiler/notes/compiler_design.html: Mention the new module. compiler/options.m: Add an option, --experimental-complexity. Its argument is a filename that specifies the list of procedures to transform. Add an option, --no-allow-inlining, to disallow all inlining. This is simpler to use than specifying several options to turn off each potential reason to inline procedures. doc/user_guide.texi: Document the new options. The documentation present now is only a shell; it will be expanded later. compiler/table_gen.m: compiler/goal_util.m: Move the predicate for creating renamings from table_gen.m to goal_util.m, since complexity.m also needs it now. In the process, make it more general by allowing outputs to have more complex modes than simply `out'. compiler/goal_util.m: Fix a bug exposed by the new transformation: when renaming goals (e.g. for quantification), rename the variables holding information about term sizes. compiler/handle_options.m: Disable inlining if experimental complexity analysis is enabled. compiler/compile_target_code.m: Pass the --experimental-complexity option on to the linker. library/term_size_prof_builtin.m: Add the Mercury predicates that serve as interfaces to the primitives needed by the experimental complexity transformation. runtime/mercury_term_size.[ch]: Add the implementations of the primitives needed by the experimental complexity transformation. runtime/mercury_wrapper.[ch]: Add global variables holding counters of the numbers of words and cells allocated so far. runtime/mercury_heap.h: Update these global variables when allocating memory. runtime/mercury_complexity.h: New file that contains the definition of the data structures holding the data collected by the experimental complexity transformation. This is separate from mercury_term_size.h, because it needs to be #included in mercury_init.h, the header file of the mkinit-generated <program>_init.c files. runtime/mercury_init.h: runtime/mercury_imp.h: #include mercury_complexity.h. util/mkinit.c: Define and initialize the data structures holding complexity information when given the -X option (mkinit doesn't have long options). Fix some deviations from our coding style. scripts/parse_ml_options.sh-subr.in: Accept the --experiment-complexity option. scripts/c2init.in: Pass the --experiment-complexity option on to mkinit.c. tools/bootcheck: Preserve the files containing the results of complexity analysis, if they exist. tools/makebatch: Allow the specification of EXTRA_MLFLAGS in the generated Mmake.stage.params files.	2005-02-15 05:22:40 +00:00