61 Commits

Author	SHA1	Message	Date
Mark Brown	d465fa53cb	Update the COPYING.LIB file and references to it. ... Discussion of these changes can be found on the Mercury developers mailing list archives from June 2018. COPYING.LIB: Add a special linking exception to the LGPL. *: Update references to COPYING.LIB. Clean up some minor errors that have accumulated in copyright messages.	2018-06-09 17:43:12 +10:00
Zoltan Somogyi	53b573692a	Convert C code to use // style comments. ... runtime/*.[ch]: trace/*.[chyl]: As above. In some places, improve comments, e.g. by expanding contractions such as "we've". Add #ifndef guards against double inclusion around the trace/*.h files that did not already have them. tools/*: Make the corresponding changes in shell scripts that generate .[ch] files in the runtime. tests/*: Conform to a slight change in the text of a message.	2016-07-14 13:57:35 +02:00
Zoltan Somogyi	67326f16e4	Fix style issues in the runtime. ... Move all .h and .c files to four-space indentation without tabs, if they weren't there already. Use the same vim line for all .h and .c files. Align all backslashes at the ends of lines in macro definitions. Align close comment signs. In some places, fix inconsistent indentation. Fix a bunch of comments. Add XXXs to a few of them.	2016-07-09 12:14:00 +02:00
Zoltan Somogyi	8d75bd09ea	Fix comment.	2014-04-18 02:02:35 +10:00
Zoltan Somogyi	f6fafa150d	Fix Mantis bug 314 for temp frames created by nondet procedures. ... Also fix some bugs in related code, and improve the related debugging infrastructure. ------------------- runtime/mercury_stacks.[ch]: Fix bug 314 for temp frames created by nondet procedures. The fix will probably also work for *det* procedures that create temp frames on the nondet stack, but I can't think of a way to test that, because det procedures create such frames only in very specific circumstances, and I cannot think of a way to nest a recursive call inside those circumstances. The problem was that when we were creating new temp frames on the nondet stack, we did not check whether the current nondet stack segment had room for them. We now do. The stack trace tracing code needs to know the size of each nondet stack frame, since it uses the size to classify frames as temp or ordinary. The size is given by the difference in address between the address of the frame and the address of the previous frame. This difference would yield an incorrect size and hence an incorrect frame classification if a temp frame were allowed to have a frame on a different segment as its immediate predecessor. We prevent this by putting an ordinary (i.e. non-temp) frame at the bottom of every new nondet stack segment as a sentinel. We hand-build this frame, since it is not an "ordinary" ordinary frame. It is not created by a call, so it has no meaningful success continuation, and since it does not make any calls, no other frame's success continuation can point to it either. If backtracking reaches this sentinel frame, we use this fact to free all the segments beyond the one the sentinel frame is in, but keep the frame the sentinel frame is in, since we are likely to need it again. Document the reason why MR_incr_sp_leaf() does not have to check whether a new stack segment is needed. (See the fix to llds_out_instr.m below.) runtime/mercury_stack_trace.[ch]: When traversing the nondet stack, treat the sentinel frame specially. We have to, since it is an ordinary frame (i.e. it is not a temp frame), but it is not an "ordinary" ordinary frame: it does not make calls, and hence calls cannot return to it, and it does not return to any other frame either. It therefore does not have the layout structures (label and proc) that the nondet stack traversal expects to find. Fix an old bug: the nondet stack traversal used a simple directional pointer comparison to check whether it has reached the bottom of the nondet stack. This is NOT guaranteed to work in the presence of stack segments: depending on exactly what addresses new stack segments get, a stack frame can have an address BELOW the address of the initial stack frame even if it is logically ABOVE that stack frame. Another old bug was that a difference between two pointers, which could be 64 bit, was stored in an int, which could be 32 bit. The nondet stack traversal code used a similar directional comparison to implement optionally stopping at an arbitrary point on the nondet stack. Fixing this facility (the limit_addr parameter of MR_dump_nondet_stack) while preserving reasonable efficiency would not be trivial, but it would also be pointless, since the facility is not actually used. This diff deletes the parameter instead. Move some loop invariant code out of its loop. trace/mercury_trace_cmd_developer.c: trace/mercury_trace_external.c: Don't pass the now-deleted parameter to mercury_stack_trace.c. runtime/mercury_wrapper.c: Record the zone of the initial nondet stack frame, since the fix of mercury_stack_trace.c needs that info, and it is much more efficient to set it up just once. tests/hard_coded/bug314.{m,exp}: The regression test for this bug. tests/hard_coded/Mercury.options: Compile the new test case with the options it needs. tests/hard_coded/Mmakefile: Enable the new test case. ------------------- runtime/mercury_wrapper.c: The compiler knows the number of words in a stack frame it is creating, not necessarily the number of bytes (though it could put bounds on that from the number of tag bits). Since this size must sync with the runtime, change the runtime's variable holding this size to also be in words. Note that similar changes would also be beneficial for other sizes. compiler/llds_out_instr.m: Conform to the change in mercury_wrapper.c, fixing an old bug (mercury_wrapper.c reserved 128 BYTES for leaf procedures, but llds_out_instr.m was using that space for procedures whose frames were up to 128 WORDS in size.) compiler/mercury_memory.c: Conform to the change in mercury_wrapper.c. ------------------- runtime/mercury_memory_zones.h: Instead of starting to use EVERY zone at a different offset, do this only for the INITIAL zones in each memory area, since only on these is it useful. When the program first starts up, it WILL be using the initial parts of the det stack, nondet stack and heap, so it is useful to make sure that these do not collide in the cache. However, when we allocate e.g. the second zone in e.g. the nondet stack, we are no more likely to be beating on the initial part of any segment of the det stack than on any other part of such segments. If a new debug macro, MR_DEBUG_STACK_SEGMENTS_SET_SIZE is set (to an int), use only that many words in each segment. This allows the segment switchover code to be exercised and debugged with smaller test cases. runtime/mercury_conf_param.h: Document the MR_DEBUG_STACK_SEGMENTS_SET_SIZE macro. Convert this file to four-space indentation with tabs expanded. ------------------- runtime/mercury_overflow.h: Make abort messages from overflows and underflows more useful by including more information. runtime/mercury_overflow.c: Add a new function to help with the better abort messages. Since this file did not exist before, create it. runtime/Mmakefile: Add the new source file to the list of source files. ------------------- runtime/mercury_debug.[ch]: Fix problems with the formatting of the debugging output from existing functions. Add new functions for dumping info about memory zones. Factor out some common code. Convert the header file to four-space indentation. ------------------- runtime/mercury_grade.c: Generate an error if stack segments are specified together with stack extension ------------------- trace/.gitignore: util/.gitignore: tests/debugger/.gitignore: List some more files. ------------------- runtime/mercury_context.c: runtime/mercury_engine.[ch]: runtime/mercury_misc.h: compiler/notes/failure.html: Fix white space.	2014-04-18 02:02:35 +10:00
Peter Wang	122579d906	Nondet stack segments didn't work properly using the placeholder frame trick ... Branches: main Nondet stack segments didn't work properly using the placeholder frame trick at the base of nondet stack segments. i.e. when we jump to special procedure (MR_pop_nondetstack_segment) stored in the succip slot of the base frame, it should free the top stack segment, set maxfr to the correct value and jump to the real succip. However, we were reading values of maxfr and succip from the *det* stack which is clearly wrong. After fixing that, it still didn't work properly. Nondet execution seems to be too haphazard for the trick to work. MR_pop_nondetstack_segment() can be entered not only when the top stack segment can be deallocated, which complicates things. Instead, switch to a simpler method to deallocate nondet stack frames. When creating a nondet frame, we know that all stack segments above that which `maxfr' points into can be freed. In the common case, `maxfr' *will* point into the top stack segment and that can be checked with just one additional test. After deallocating excess stack segments, the new frame can be created as before. See also Mantis bug #65. runtime/mercury_stacks.h: Make `MR_nondetstack_extend_and_check' check that `maxfr' still lives on the top nondet stack segment. If not, or if a new segment is required, call `MR_nondetstack_segment_extend_slow_path'. runtime/mercury_stacks.c: Rename `MR_new_detstack_segment' to `MR_nondetstack_segment_extend_slow_path'. Make it free excess nondet stack segments. Fix a bug where `MR_NONDET_FIXED_SIZE' was added twice to the number of slots required for a new frame. Delete `MR_pop_nondetstack_segment' which is no longer used. Don't use red zones for new det and nondet stack segments. Add missing parameters to some debugging code. runtime/mercury_stack_trace.c: Delete reference to `MR_pop_nondetstack_segment'. runtime/mercury_memory_zones.c: Add sanity checks for small memory zone sizes, e.g. they may be too small to fit all of the usable zone area, red zone and cache offset. NEWS: Announce stack segment support as it should be stable now.	2008-08-07 01:16:19 +00:00
Zoltan Somogyi	ecf1ee3117	Add a mechanism for growing the stacks on demand by adding new segments ... Estimated hours taken: 20 Branches: main Add a mechanism for growing the stacks on demand by adding new segments to them. You can ask for the new mechanism via a new grade component, stseg (short for "stack segments"). The mechanism works by adding a test to each increment of a stack pointer (sp or maxfr). If the test indicates that we are about to run out of stack, we allocate a new stack segment, allocate a placeholder frame on the new segment, and then allocate the frame we wanted in the first place on top of the placeholder. We also override succip to make it point code that will (1) release the new segment when the newly created stack frame returns, and then (2) go to the place indicated by the original, overridden succip. For leaf procedures on the det stack, we optimize away the check of the stack pointer. We can do this because we reserve some space on each stack for the use of such stack frames. My intention is that doc/user_guide.texi and NEWS will be updated once we have used the feature ourselves for a while and it seems to be stable. runtime/mercury_grade.h: Add the new grade component. runtime/mercury_conf_param.h: Document the new grade component, and the option used to debug stack segments. runtime/mercury_context.[ch]: Add new fields to contexts to hold the list of previous segments of the det and nondet stacks. runtime/mercury_memory_zones.[ch]: Include a threshold in all zones, for use in stack segments. Set it when a zone is allocated. Restore the previous #ifdef'd out function MR_unget_zone, for use when freeing stack segments execution has fallen out of. runtime/mercury_debug.[ch]: When printing the offsets of pointers into the det and nondet stacks, print the number of the segment the pointer points into (unless it is the first, in which case we suppress this in the interest of brevity and simplicity). Make all the functions in this module take a FILE * as an input argument; don't print to stdout by default. runtime/mercury_stacks.[ch]: Modify the macros that allocate stack frames to invoke the code for adding new stack segments when we are about to run out of stack. Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. Conform to the changes in mercury_debug.c. runtime/mercury_stack_trace.c: When traversing the stack, step over the placeholder stack frames at the bottoms of stack segments. Conform to the changes in mercury_debug.c. runtime/mercury_wrapper.[ch]: Make the default stack size small in grades that support stack segments. Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. Conform to the changes in mercury_debug.c. runtime/mercury_memory.c: Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. runtime/mercury_engine.[ch]: runtime/mercury_overflow.h: Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. Convert these files to four-space indentation. runtime/mercury_minimal_model.c: trace/mercury_trace.c: trace/mercury_trace_util.c: Conform to the changes in mercury_debug.c. compiler/options.m: Add the new grade option for stack segments. compiler/compile_target_code.m: compiler/handle_options.m: Add the new grade component, and handle its exclusions with other grade components and optimizations. compiler/llds.m: Extend the incr_sp instruction to record whether the stack frame is for a leaf procedure. compiler/llds_out.m: Output the extended incr_sp instruction. compiler/proc_gen.m: Fill in the extra slot in incr_sp instructions. compiler/goal_util.m: Provide a predicate for testing whether a procedure body is a leaf. compiler/delay_slot.m: compiler/dupelim.m: compiler/dupproc.m: compiler/exprn_aux.m: compiler/frameopt.m: compiler/global_data.m: compiler/jumpopt.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/peephole.m: compiler/reassign.m: compiler/use_local_vars.m: Conform to the change in llds.m. scripts/canonicate_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: scripts/final_grade_options.sh-subr: scripts/mgnuc.in: Handle the new grade component. Convert parse_grade_options.sh-subr to four-space indentation. Mmake.workspace: Fix an old bug that prevented bootcheck from working in the new grade: when computing the gc grade, use the workspace's version of ml (which in this case understands the new grade components), rather than the installed ml (which does not). (This was a devil to track down, because neither make --debug nor strace on make revealed how the installed ml was being invoked, and there was no explicit invocation in the Makefile either; the error message appeared to come out of thin air just before the completion of the stage 2 library. It turned out the invocation happened implicitly, as a result of expanding a make variable.)	2006-11-01 02:31:19 +00:00
Peter Wang	712027f307	This patch changes the parallel execution mechanism in the low level backend. ... Estimated hours taken: 100 Branches: main This patch changes the parallel execution mechanism in the low level backend. The main idea is that, even in programs with only moderate parallelism, we won't have enough processors to exploit it all. We should try to reduce the cost in the common case, i.e. when a parallel conjunction gets executed sequentially. This patch does two things along those lines: (1) Instead of unconditionally executing all parallel conjuncts (but the last) in separate Mercury contexts, we allow a context to continue execution of the next conjunct of a parallel conjunction if it has just finished executing the previous conjunct. This saves on allocating unnecessary contexts, which can be a big reduction in memory usage. We also try to execute conjuncts left-to-right so as to minimise the need to suspend contexts when there are dependencies between conjuncts. (2) Conjuncts that *are* executed in parallel still need separate contexts. We used to pass variable bindings to those conjuncts by flushing input variable values to stack slots and copying the procedure's stack frame to the new context. When the conjunct finished, we would copy new variable bindings back to stack slots in the original context. What happens now is that we don't do any copying back and forth. We introduce a new abstract machine register `parent_sp' which points to the location of the stack pointer at the time that a parallel conjunction began. In parallel conjuncts we refer to all stack slots via the `parent_sp' pointer, since we could be running on a different context altogether and `sp' would be pointing into a new detstack. Since parallel conjuncts now share the procedure's stack frame, we have to allocate stack slots such that all parallel conjuncts in a procedure that could be executing simultaneously have distinct sets of stack slots. We currently use the simplest possible strategy, i.e. don't allow variables in parallel conjuncts to reuse stack slots. Note: in effect parent_sp is a frame pointer which is only set for and used by the code of parallel conjuncts. We don't call it a frame pointer as it can be confused with "frame variables" which have to do with the nondet stack. compiler/code_info.m: Add functionality to keep track of how deep inside of nested parallel conjunctions the code generator is. Add functionality to acquire and release "persistent" temporary stack slots. Unlike normal temporary stack slots, these don't get implicitly released when the code generator's location-dependent state is reset. Conform to additions of `parent_sp' and parent stack variables. compiler/exprn_aux.m: Generalise the `substitute_lval_in_*' predicates by `transform_lval_in_*' predicates. Instead of performing a fixed substitution, these take a higher order predicate which performs some operation on each lval. Redefine the substitution predicates in terms of the transformation predicates. Conform to changes in `fork', `join_and_terminate' and `join_and_continue' instructions. Conform to additions of `parent_sp' and parent stack variables. Remove `substitute_rval_in_args' and `substitute_rval_in_arg' which were unused. compiler/live_vars.m: Introduce a new type `parallel_stackvars' which is threaded through `build_live_sets_in_goal'. We accumulate the sets of variables which are assigned stack slots in each parallel conjunct. At the end of processing a parallel conjunction, use this information to force variables which are assigned stack slots to have distinct slots. compiler/llds.m: Change the semantics of the `fork' instruction. It now takes a single argument: the label of the next conjunct after the current one. The instruction now "sparks" the next conjunct to be run, either in a different context (possibly in parallel, on another Mercury engine) or is queued to be executed in the current context after the current conjunct is finished. Change the semantics of the `join_and_continue' instruction. This instruction now serves to end all parallel conjuncts, not just the last one in a parallel conjunction. Remove the `join_and_terminate' instruction (no longer used). Add the new abstract machine register `parent_sp'. Introduce "parent stack slots", which are similar to normal stack slots but relative to the `parent_sp' register. compiler/par_conj_gen.m: Change the code generated for parallel conjunctions. That is: - use the new `fork' instruction at the beginning of a parallel conjunct; - use the `join_and_continue' instruction at the end of all parallel conjuncts; - keep track of how deep the code generator currently is in parallel conjunctions; - set and restore the `parent_sp' register when entering a non-nested parallel conjunction; - after generating the code of a parallel conjunct, replace all references to stack slots by parent stack slots; - remove code to copy back output variables when a parallel conjunct finishes. Update some comments. runtime/mercury_context.c: runtime/mercury_context.h: Add the type `MR_Spark'. Sparks are allocated on the heap and contain enough information to begin execution of a single parallel conjunct. Add globals `MR_spark_queue_head' and `MR_spark_queue_tail'. These are pointers to the start and end of a global queue of sparks. Idle engines can pick up work from this queue in the same way that they can pick up work from the global context queue (the "run queue"). Add new fields to the MR_Context structure. `MR_ctxt_parent_sp' is a saved copy of the `parent_sp' register for when the context is suspended. `MR_ctxt_spark_stack' is a stack of sparks that we decided not to put on the global spark queue. Update `MR_load_context' and `MR_save_context' to save and restore `MR_ctxt_parent_sp'. Add the counters `MR_num_idle_engines' and `MR_num_outstanding_contexts_and_sparks'. These are used to decide, when a `fork' instruction is reached, whether a spark should be put on the global spark queue (with potential for parallelism but also more overhead) or on the calling context's spark stack (no parallelism and less overhead). Rename `MR_init_context' to `MR_init_context_maybe_generator'. When initialising contexts, don't reset redzones of already allocated stacks. It seems to be unnecessary (and the reset implementation is buggy anyway, though it's fine on Linux). Rename `MR_schedule' to `MR_schedule_context'. Add new functions `MR_schedule_spark_globally' and `MR_schedule_spark_locally'. In `MR_do_runnext', add code for idle engines to get work from the global spark queue. Resuming contexts are prioritised over sparks. Rename `MR_fork_new_context' to `MR_fork_new_child'. Change the definitions of `MR_fork_new_child' and `MR_join_and_continue' as per the new behaviour of the `fork' and `join_and_continue' instructions. Delete `MR_join_and_terminate'. Add a new field `MR_st_orig_context' to the MR_SyncTerm structure to record which context originated the parallel conjunction instance represented by a MR_SyncTerm instance, and update `MR_init_sync_term'. This is needed by the new behaviour of `MR_join_and_continue'. Update some comments. runtime/mercury_engine.h: runtime/mercury_regs.c: runtime/mercury_regs.h: runtime/mercury_stacks.h: Add the abstract machine register `parent_sp' and code to copy it to and from the fake_reg array. Add a macro `MR_parent_sv' to access stack slots via `parent_sp'. Add `MR_eng_parent_sp' to the MercuryEngine structure. runtime/mercury_wrapper.c: runtime/mercury_wrapper.h: Add Mercury runtime option `--max-contexts-per-thread' which is saved in the global variable `MR_max_contexts_per_thread'. The number `MR_max_outstanding_contexts' is derived from this. It sets a soft limit on the number of sparks we put in the global spark queue, relative to the number of threads we are running. We don't want to put too many sparks on the global queue if there are plenty of ready contexts or sparks already on the global queues, as they are likely to result in new contexts being allocated. When initially creating worker engines, wait until all the worker engines have acknowledged that they are idle before continuing. This is mainly so programs (especially benchmarks and test cases) with only a few fork instructions near the beginning of the program don't execute the forks before any worker engines are ready, resulting in no parallelism. runtime/mercury_engine.c: runtime/mercury_thread.c: Don't allocate a context at the time a Mercury engine is created. An engine only needs a new context when it is about to pick up a spark. configure.in: compiler/options.m: scripts/Mercury.config.in: Update to reflect the extra field in MR_SyncTerm. Add the option `--sync-term-size' and actually make use the result of the sync term size calculated during configuration. compiler/code_util.m: compiler/continuation_info.m: compiler/dupelim.m: compiler/dupproc.m: compiler/global_data.m: compiler/hlds_llds.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/reassign.m: compiler/stack_layout.m: compiler/use_local_vars.m: compiler/var_locn.m: Conform to changes in `fork', `join_and_terminate' and `join_and_continue' instructions. Conform to additions of `parent_sp' and parent stack variables. XXX not sure about the changes in stack_layout.m library/par_builtin.m: Conform to changes in the runtime system.	2006-09-26 03:53:23 +00:00
Zoltan Somogyi	e404069258	Provide better error messages when minimal model code cannot be evaluated ... Estimated hours taken: 3 Branches: main Provide better error messages when minimal model code cannot be evaluated due to the limits of our current program transformation technique. runtime/mercury_stacks.[ch]: Add an extra argument, a string, to MR_pneg_enter_else. If MR_pneg_enter_else has to abort, print this string first. compiler/ite_gen.m: When generating the wrappers around possibly negated contexts, add an argument to MR_pneg_enter_else that gives the current context. library/std_util.m: Add the argument to a hand-written call to MR_pneg_enter_else. tests/.mgnuc_opts: New file that turns off the searching of the standard (i.e. the installed) directories for header files. It is needed because without it, gcc would find the old, no-argument MR_pneg_enter_else declaration in the installed mercury_stacks.h. This is ok because the already existing .mgnuc_copts file tells gcc to look for header files in the relevant stage directories. tools/bootcheck: Copt tests/.mgnuc_opts to the various test directories. tests/tabling/consumer_in_solutions.exp: Update the expected output of this test case.	2005-11-25 05:40:55 +00:00
Zoltan Somogyi	753d9755ae	When returning from det and semidet predicates, load the return address into a ... Estimated hours taken: 3 Branches: main When returning from det and semidet predicates, load the return address into a local C variable instead of the succip abstract machine "register" before popping the stack frame and returning. This gives the C compiler more freedom to reorder instructions. This diff gets a 1.4% speed increase on the compiler. runtime/mercury_stacks.h: Provide a new macro, MR_decr_sp_and_return, to do the combined job that its name describes. compiler/llds.m: Add a new LLDS instruction that corresponds to the new macro. compiler/llds_out.m: Output the new LLDS instruction. compiler/peephole.m: Add a predicate that looks for and exploits opportunities for using the new instruction. compiler/optimize.m: Invoke the new peephole predicate as the next-to-last optimization pass. (The last is wrapping up blocks created by --use-local-vars.) compiler/*.m: Minor changes to handle the new instruction.	2005-09-14 01:29:21 +00:00
Zoltan Somogyi	1ed891b7b1	Introduce a mechanism for extending the det and nondet stacks when needed. ... Estimated hours taken: 24 Branches: main Introduce a mechanism for extending the det and nondet stacks when needed. The mechanism takes the form of a new grade component, .exts ("extend stacks"). While the new mechanism may be useful in its own right, it is intended mainly to support a new implementation of minimal model tabling, which will use a separate Mercury context for each distinct subgoal. Each context has its own det and nondet stack. Clearly, we can't have hundreds of contexts each with megabyte sized det stacks. The intention is that the stacks of the subgoals will start small, and be expanded when needed. The runtime expansion of stacks doesn't work yet, but it is unnecessarily hard to debug without an installed compiler that understands the new grade component, which is why this diff will be committed before that is fixed. compiler/handle_options.m: compiler/options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr scripts/init_grade_options.sh-subr scripts/parse_grade_options.sh-subr scripts/mgnuc.in Handle the new grade component. runtime/mercury_memory_zones.h: Add MR_ prefixes to the names of the fields of the zone structure. Record not just the actual size of each zone, which includes various kinds of buffers, but also the desired size of the zone exclusive of buffers. Format the documentation of the zone structure fields more comprehensibly. runtime/mercury_memory_zones.c: Instead of implementing memalign if it is not provided by the operating system, implement a function that allows us to reallocate the returned area of memory. Provide a prototype implementation of memory zone extension. It doesn't work yet. Factor out the code for setting up redzones, since it is now needed in more than place. Convert to four space indentation. Make the debugging functions a bit more flexible. runtime/mercury_wrapper.c: Conform to the improved interface of the debugging functions. runtime/mercury_overflow.h: runtime/mercury_std.h: Move a generally useful macro from mercury_overflow.h to mercury_std.h. runtime/mercury_stacks.c: Add functions to extend the stacks. runtime/mercury_stacks.h: Add the tests required to invoke the functions that extend the stacks. Add the macros needed by the change to compiler/llds.m. Convert to four space indentation. runtime/mercury_conf.h.in: Prepare for the use of the posix_memalign function, which is the current replacement of the obsolete memalign library function. We don't yet use it. runtime/mercury_context.h: Format the documentation of the context structure fields more comprehensibly. Put MR_ prefixes on the names of the fields of some structures that didn't previously have them. Conform to the new names of the fields of the zone structure. runtime/mercury_context.c: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_engine.c: runtime/mercury_memory_handlers.c: library/benchmarking.m: library/exception.m: Conform to the new names of the fields of the zone structure. In some cases, add missing MR_ prefixes to function names and/or convert to four space indentation. runtime/mercury_engine.h: Add a new low level debug flag for debugging stack extensions. Format the documentation of the engine structure fields more comprehensibly. Convert to four space indentation. runtime/mercury_conf_param.h: Document a new low level debug flag for debugging stack extensions. compiler/compile_target_code.m: compiler/handle_options.m: compiler/options.m: Handle the new grade component. compiler/llds.m: Add two new kinds of LLDS instructions, save_maxfr and restore_maxfr. These are needed because the nondet stack may be relocated between saving and the restoring of maxfr, and the saved maxfr may point to the old stack. In .exts grades, these instructions will save not a pointer but the offset of maxfr from the start of the nondet stack, since offsets are not affected by the movement of the nondet stack. compiler/code_info.m: Use the new instructions where relevant. (Some more work may be needed on this score; the relevant places are marked with XXX.) compiler/dupelim.m: compiler/dupproc.m: compiler/exprn_aux.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/reassign.m: compiler/use_local_vars.m: Handle the new LLDS instructions. tools/bootcheck: Provide a mechanism for setting the initial stack sizes for a bootcheck.	2005-09-13 08:25:44 +00:00
Zoltan Somogyi	b4d5df4162	Provide mechanisms for measuring individually the main sources of overheads ... Estimated hours taken: 1 Branches: Provide mechanisms for measuring individually the main sources of overheads of minimal model tabling. This was required for the paper I have just finished with Kostis. runtime/mercury_stacks.h: Allow the inclusion of the extra nondet stack slot needed in minimal-model grades to be added even in non-minimal-model grades. compiler/options.m: Add two new options, --disable-mm-pneg and --disable-mm-cut, that ask the code generator not to generate code for manipulating the pneg stack and the cut stack respectively. Add two new options for internal use by the compiler only, that say whether the compiler should emit code for handling the pneg stack and cut stack respectively. None of the options is documented, since they are not for users. compiler/handle_options.m: Set the options to ask for the code for the pneg and cut stacks in minimal-model grades, unless the relevant disable option is given. compiler/code_info.m: compiler/ite_gen.m: Instead of testing the minimal model grade option to see whether to emit code for the cut stack and pneg stack respectively, test the relevant new option.	2005-05-17 04:19:25 +00:00
Zoltan Somogyi	e854a5f9d9	Major improvements to tabling, of two types. ... Estimated hours taken: 32 Branches: main Major improvements to tabling, of two types. The first is the implementation of the loopcheck and memo forms of tabling for model_non procedures, and the second is a start on the implementation of a new method of implementing minimal model tabling, one that has the potential for a proper fix of the problem that we currently merely detect with the pneg stack (the detection is followed by a runtime abort). Since this new method relies on giving each own generator its own stack, the grade component denoting it is "mmos" (minimal model own stack). The true name of the existing method is changed from "mm" to "mmsc" (minimal model stack copy). The grade component "mm" is now a shorthand for "mmsc"; when the new method works, "mm" will be changed to be a shorthand for "mmos". configure.in: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: scripts/final_grade_options.sh-subr: compiler/options.m: Handle the new way of handling minimal model grades. scripts/mgnuc.in: compiler/compile_target_code.m: Conform to the changes in minimal model grade options. compiler/table_gen.m: Implement the transformations required by the loopcheck and memo tabling of model_non procedures, and the minimal model own stack transformation. The new implementation transformations use foreign_procs with extra args, since there is no point in implementing them both that way and with separate calls to library predicates. This required making the choice of which method to use at the top level of each transformation. Fix an oversight that hasn't caused problems yet but may in the future: mark goals wrapping the original goals as not impure for determinism computations. compiler/handle_options.m: Handle the new arrangement of the options for minimal model tabling. Detect simultaneous calls for both forms of minimal model tabling, and generate an error message. Allow for more than one error message generated at once; report them all once rather than separately. compiler/globals.m: Add a mechanism to allow a fix a problem detected by the changes to handle_options: the fact that we currently may generate a usage message more than once for invocations with more than one error. compiler/mercury_compile.m: compiler/make.program_target.m: compiler/make.util.m: Use the new mechanism in handle_options to avoid generating duplicate usage messages. compiler/error_util.m: Add a utility predicate for use by handle_options. compiler/hlds_pred.m: Allow memo tabling for model_non predicates, and handle own stack tabling. compiler/hlds_out.m: Print information about the modes of the arguments of foreign_procs, since this is useful in debugging transformations such as tabling that generate them. compiler/prog_data.m: compiler/layout_out.m: compiler/prog_out.m: runtime/mercury_stack_layout.h: Mention the new evaluation method. compiler/goal_util.m: Change the predicates for creating calls and foreign_procs to allow more than one goal feature to be attached to the new goal. table_gen.m now uses this capability. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/polymorphism.m: compiler/simplify.m: compiler/size_prof.m: compiler/typecheck.m: compiler/unify_proc.m: Conform to the changes in goal_util. compiler/code_info.m: compiler/make_hlds.m: compiler/modules.m: compiler/prog_io_pragma.m: Conform to the new the options controlling minimal model tabling. compiler/prog_util.m: Add a utility predicate for use by table_gen.m. library/std_util.m: Conform to the changes in the macros for minimal model tabling grades. library/table_builtin.m: Add the types and predicates required by the new transformations. Delete an obsolete comment. runtime/mercury_grade.h: Handle the new minimal model grade component. runtime/mercury_conf_param.h: List macros controlling minimal model grades. runtime/mercury_tabling.[ch]: Define the types needed by the new transformations, Implement the performance-critical predicates that need to be hand-written for memo tabling of model_non predicates. Add utility predicates for debugging. runtime/mercury_tabling_preds.h: Add the implementations of the predicates required by the new transformations. runtime/mercury_mm_own_stacks.[ch]: This new module contains the first draft of the implementation of the own stack implementation of minimal model tabling. runtime/mercury_imp.h: Include the new file if the grade needs it. runtime/Mmakefile: Mention the new files, and sort the lists of filenames. runtime/mercury_tabling_macros.h: Add a macro for allocating answer blocks without requiring them to be pointed to directly by trie nodes. runtime/mercury_minimal_model.[ch]: The structure type holding answer lists is now in mercury_tabling.h, since it is now also needed by memo tabling of model_non predicates. It no longer has a field for an answer num, because while it is ok to require a separate grade for debugging minimal model tabling, it is not ok to require a separate grade for debugging memo tabling of model_non predicates. Instead of printing the answer numbers, print the answers themselves when we need to identify solutions for debugging. Change function names, macro names, error messages etc where this is useful to distinguish the two kinds of minimal model tabling. Fix some oversights wrt transient registers. runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_memory.[ch]: runtime/mercury_wrapper.[ch]: With own stack tabling, each subgoal has its own context, so record the identity of the subgoal owning a context in the context itself. The main computation's context is the exception: it has no owner. Record not just the main context, but also the contexts of subgoals in the engine. Add variables for holding the sizes of the det and nondet stacks of the contexts of subgoals (which should in general be smaller than the sizes of the corresponding stacks of the main context), and initialize them as needed. Initialize the variables holding the sizes of the gen, cut and pneg stacks, even in grades where the stacks are not used, for safety. Fix some out-of-date documentation, and conform to our coding guidelines. runtime/mercury_memory_zones.[ch]: Add a function to test whether a pointer is in a zone, to help debugging. runtime/mercury_debug.[ch]: Add some functions to help debugging in the presence of multiple contexts, and factor out some common code to help with this. Delete the obsolete, unused function MR_printdetslot_as_label. runtime/mercury_context.h: runtime/mercury_bootstrap.h: Move a bootstrapping #define from mercury_context.h to mercury_bootstrap.h. runtime/mercury_context.h: runtime/mercury_bootstrap.h: Move a bootstrapping #define from mercury_context.h to mercury_bootstrap.h. runtime/mercury_types.h: Add some more forward declarations of type names. runtime/mercury_dlist.[ch]: Rename a field to avoid assignments that dereference NULL. runtime/mercury_debug.c: runtime/mercury_memory.c: runtime/mercury_ml_expand_body.h: runtime/mercury_stack_trace.c: runtime/mercury_stacks.[ch]: trace/mercury_trace_util.c Update uses of the macros that control minimal model tabling. runtime/mercury_stack_trace.c: Provide a mechanism to allow stack traces to be suppressed entirely. The intention is that by using this mechanism, by the testing system won't have to provide separate .exp files for hlc grades, nondebug LLDS grades and debug LLDS grades, as we do currently. The mechanism is the environment variable MERCURY_SUPPRESS_STACK_TRACE. tools/bootcheck: tools/test_mercury: Specify MERCURY_SUPPRESS_STACK_TRACE. trace/mercury_trace.c: When performing retries across tabled calls, handle memo tabled model_non predicates, for which the call table tip variable holds a record with a back pointer to a trie node, instead of the trie node itself. trace/mercury_trace_internal.c: When printing tables, handle memo tabled model_non predicates. Delete the code now moved to runtime/mercury_tabling.c. Add functions for printing the data structures for own stack minimal model tabling. tests/debugger/print_table.{m,inp,exp}: Update this test case to also test the printing of tables for memo tabled model_non predicates. tests/debugger/retry.{m,inp,exp}: Update this test case to also test retries across memo tabled model_non predicates. tests/tabling/loopcheck_nondet.{m,exp}: tests/tabling/loopcheck_nondet_non_loop.{m,exp}: New test cases to test loopcheck tabled model_non predicates. One test case has a loop to detect, one doesn't. tests/tabling/memo_non.{m,exp}: tests/tabling/tc_memo.{m,exp}: tests/tabling/tc_memo2.{m,exp}: New test cases to test memo tabled model_non predicates. One test case has a loop to detect, one has a need for minimal model tabling to detect, and the third doesn't have either. tests/tabling/Mmakefile: Add the new test cases, and reenable the existing tc_loop test case. Rename some make variables and targets to make them better reflect their meaning. tests/tabling/test_mercury: Conform to the change in the name of the make target.	2004-07-20 04:41:55 +00:00
Zoltan Somogyi	8190c16181	Get Mercury to work with gcc 3.4. This required fixing several problems. ... Estimated hours taken: 16 Branches: main Get Mercury to work with gcc 3.4. This required fixing several problems. One problem that caused errors is that gcc 3.4 is smart enough to figure out that in LLDS grades with gcc gotos, the C functions containing our code are not referred to, and so it optimizes them away. The fix is to ensure that mercury_<module>_init is defined always to call those functions, even if the macro that usually controls this, MR_MAY_NEED_INITIALIZATION, is not defined. The mercury_<module>_init won't be called from the init_modules function in the program's _init.c file, so there is no impact on initialization time, but gcc doesn't know this when compiling a module's .c file, so it doesn't optimize away the code we need. The cost of this change is thus only a small amount of code space. It is worth paying this cost even with compilers other than gcc 3.4 for simplicity. Actually, this size increase seems to be slightly smaller than the size reduction due to the better optimization capabilities of gcc 3.4 compared to gcc 3.2.2. A second problem is that gcc 3.4 warns about casts in lvalues being a deprecated feature. This gave lots of warnings, since we used to define several Mercury abstract machine registers, including MR_succip, MR_hp, MR_sp, MR_maxfr and MR_curfr using lvalue casts. The fix is to have two macros for each of these abstract machine registers, one of type MR_Word that you can assign to (e.g. MR_sp_word), and one of the original type that is of the right type but not an lvalue (e.g. MR_sp). The lvalue itself can't be made the right type, because MR_sp isn't a variable in its own right, but possibly defined to be a machine register. The machine register could made the right type, but only at the cost of a lot of complexity. This problem doesn't apply to the special-purpose Mercury abstract machine registers that can't be allocated to machine registers. Instead of #defining these to slots in MR_fake_reg, we make them global variables of the natural type. This should also make it easier to debug code using these registers. We treat these global variables as if they were machine registers in that MR_save_registers copies values from these global variables to slots reserved for them in the MR_fake_reg array, to allow code to loop over all Mercury abstract machine registers. These saved slots must of course be of type MR_Word, so we again need two macros to refer to them, a lvalue of type MR_Word and an rvalue with the right type. A third problem is that gcc 3.4 warns about conditionals in lvalues being a deprecated feature. This gave a few warnings, since we used to define MR_virtual_reg and MR_saved_reg using lvalues using conditionals. The fix is to have one macro (MR_virtual_reg_value) for use in rvalues and a separate macro which uses an if-then-else instead of a conditional expression (MR_virtual_reg_assign), for assignments. A fourth problem is that gcc 3.4 warns about comma operators in lvalues being a deprecated feature. This gave warnings in the few places where we refer to MR_r(N) for values of N that can map to fake registers directly, since in those cases we preceded the reference to the fake_reg array with a range check of the array index. The fix to this is to move the test to compile time for compiler-generated code. Hand-written code never refers to MR_r(N) for these values, and is very unlikely to do so in the future; instead, it refers to the underlying fake_reg array directly, since that way it doesn't have to worry about which fake registers have their own MR_rN macro and which don't. Therefore no check mechanism for hand-written code is necessary. This change mean that changing the number of MR_rN registers now requires change to the compiler as well as to the runtime system. A fifth problem is that gcc 3.4 by default assumes -fstrict-aliasing at -O2. Since we cast between integers and pointers of different types all the time, and changing that is not practical, at least in the short term, we need to disable -fstrict-aliasing when we enable -O2. NEWS: Note that Mercury now works with gcc 3.4. configure.in: scripts/mgnuc.in: Detect whether the compiler supports -fstrict-aliasing, and if so, whether it assumes it by default with -O2. If the answer is yes to both, make mgnuc specify -fno-strict-aliasing when it specifies -O2. By including it in CFLAGS_FOR_OPT, which gets put into Mercury.config, we also get -f-no-strict-aliasing when mmc invokes the C compiler directly. compiler/llds_out.m: Don't generate #ifdef MR_MAY_NEED_INITIALIZATION around the definitions and calls to the bunch functions, which call the functions we don't want the C compiler to optimize away. Generate the newly required lvalues on the left sides of assignments. We still have code to generate LVALUE_CASTs in some cases, but I don't think those cases ever arise. Add a compile-time check of register numbers. Ideally, the code generator should use stack slots instead of registers beyond the max number, but I don't recall us ever bumping into this limit by accident. compiler/fact_table.m: Use the newly required lvalues on the left sides of assignments in some hand-written C code included in generated .c files. runtime/mercury_regs.h: Make the changes described above to fix the second, third and fourth problems. We still use comma operators in lvalues when counting references to registers, but it is OK to require anyone who wants to enable this feature to use a compiler version that supports comma operators in lvalues or to ignore the warnings. Use the same mapping from Mercury abstract machine registers to the register count array as to the MR_fake_reg array. Have this mapping depend as little as possible on whether we need a real machine register to store MR_engine base, even if it costs a wasted slot in MR_fake_reg. Fix an old inconsistency: treat the Mercury abstract machine registers used for trailing the same way as the other Mercury abstract machine registers, by making MR_save_registers/MR_restore_registers copy them to and from their global variable homes. Document the requirement for the match between the runtime's and the compiler's notions of the maximum MR_rN register number. This requirement makes it harder for users to increase the number of virtual registers, but as far as I know noone has wanted to do this. Change the names of some of the macros to make them clearer. Reorder some parts of this file, and add some documentation, also in the interest of clarity. runtime/mercury_regorder.h: Delete this file after moving its contents, in much modified form, to mercury_regs.h. mercury_regorder.h was always logically part of mercury_regs.h, but was separated out to make it easier to change the mapping from Mercury abstract machine registers to machine registers. However, the cost of incompatibility caused by any such changes would be much greater that any likely performance benefit. runtime/Mmakefile: Remove the reference to mercury_regorder.h. runtime/mercury_regs.[ch]: runtime/mercury_memory_zones.[ch]: Move some functionality dealing with registers from mercury_memory_zones to mercury_regs, since it belongs there. runtime/mercury_regs.[ch]: Add a function to make it easiler to debug changes to map from Mercury abstract machine to MR_fake_reg slots. runtime/mercury_regs.[ch]: runtime/mercury_wrapper.c: Move the code to print counts of register uses from mercury_wrapper.c to mercury_regs.c. Make mercury_wrapper.c call the debugging function in mercury_regs.c if -X is specified in MERCURY_OPTIONS. runtime/mercury_bootstrap.h: Move the old MR_saved_reg and MR_virtual_reg macros from mercury_regs.h to mercury_bootstrap.h to prevent their accidental use. Since they shouldn't be used by user code, move them to the section that is not enabled by default. runtime/mercury_stacks.[ch]: Add _word versions of the macros for stack slots, for the same reason why we need them for Mercury abstract machine registers, and use them. Add global variables for the Mercury abstract machine registers for the gen, cut and pneg stacks. runtime/mercury_heap.h: Change the macros for allocating memory to assign to MR_hp_word instead of MR_hp. runtime/mercury_string.h: Change the macros for allocating strings to accomodate the updates to mercury_heap.h. Also change the expected type of the target to make it MR_String instead of MR_ConstString, since the latter requires casts in the caller. runtime/mercury_trail.h: runtime/mercury_types.h: Move the definition of the type MR_TrailEntry from mercury_trail.h to mercury_types.h, since it is now used in mercury_regs.h. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_calls.h: runtime/mercury_context.[ch]: runtime/mercury_deconstruct_macros.h: runtime/mercury_deep_copy_body.h: runtime/mercury_engine.[ch]: runtime/mercury_hand_compare_body.h: runtime/mercury_hand_unify_body.h: runtime/mercury_ho_call.c: runtime/mercury_layout_util.c: runtime/mercury_make_type_info_body.h: runtime/mercury_minimal_model.c: runtime/mercury_ml_deconstruct_body.h: runtime/mercury_ml_functor_body.h: runtime/mercury_stack_layout.h: runtime/mercury_type_desc.c: runtime/mercury_type_info.c: runtime/mercury_unify_compare_body.h: runtime/mercury_wrapper.c: Conform to the changes in the rest of the runtime. In some cases, fix inconsistencies in indentation. runtime/mercury_stack_trace.c: Add some conditionally compiled debugging code controlled by the macro MR_ADDR_DEBUG, to help debug some problems with stored stack pointers. runtime/mercury_grade.h: Increment the binary compatibility version number. This is needed to avoid potential problems when a Mercury module and the debugger are compiled with different versions of the macros in mercury_regs.h. library/exception.m: Update the code that assigns to abstract machine registers. library/array.m: library/construct.m: library/dir.m: library/io.m: library/string.m: Conform to the new definitions of allocation macros. library/time.m: Delete an unnecessary #include. trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_util.c: Conform to the changes in the rest of the runtime. tests/hard_coded/qual_test_is_imported.m: tests/hard_coded/aditi_private_builtin.m: Remove an unnecessary import to avoid a warning. tools/makebatch: Add an option --save-stage2-on-error, that saves the stage2 directory if a bootcheck fails. scripts/ml.in: Make ml more robust in the face of garbage files.	2004-07-07 07:11:22 +00:00
Zoltan Somogyi	cdf0383b52	Fix a bunch of problems with tabling that I identified in Uppsala. ... Estimated hours taken: 32 Branches: main Fix a bunch of problems with tabling that I identified in Uppsala. These fall into two categories. First, the tabling transformations we were using were dividing work up too finely. This had three bad effects. First, it caused too much time to be spent on transmitting data to and from library predicates. Second, it made the transformations hard to document and hard to explain in a paper. Third, it caused us to misidentify just what the various forms of tabling have in common, and what forms of tabling work for what determinisms. To fix this problem, this diff reorients table_builtin.m and table_gen.m from being divided primarily by determinism to being divided by evaluation method. Second, we weren't being careful in separating out the parts of the tabling data structures that are needed only for debugging the tabling system itself. The fix for this is to introduce a new grade flag, MR_MINIMAL_MODEL_DEBUG, intended for use by implementors only, to govern whether the tabling data structures include debug-only components. (If this flag weren't a grade flag, the sizes of data structures created in files with different values of this flag could be inconsistent, which is something you don't want when debugging the complex code of the tabling infrastructure.) compiler/table_gen.m: Reorganize the simple (loopcheck and memo) tabling transformations completely. Instead of separate transformations for model_det and model_semi predicates, have separate transformations for loopcheck and memo predicates, since this makes it easier to see (and to ensure) that the transformation follows the required scheme. Instead of generating nested if-then-elses, generate switches when possible. For model_semi loopcheck and memo predicates, generate Mercury code that obeys our scope rules by not binding output variables in the condition of the one remaining if-then-else. Finetune the minimal model tabling transformation by combining some operations where this improves clarity and performance. Order the transformation predicates logically, and move the documentation of each form of tabling next to the code implementing that form of tabling. Attach call_table_gen markers to the setup goals that now all loopcheck, memo and minimal model tabled predicates have, to avoid having to special case the last lookup goal, and to avoid having to have separate code for lookups in call tables versus answer tables. Generate unique and more meaningful variable names. Change some predicate names to be more meaningful, both here and in the transformed code. Factor out some common code, e.g. for generating lookup goals, for generating instmap_deltas and for attaching hide_debug_event markers to goals. Report errors in cases where the arguments of a tabled predicate aren't completely input or output. compiler/hlds_pred.m: Be more strict about the determinisms of tabled predicates; permit only the determinisms we really support in all cases, and do not permit the ones that may happen to work in some cases. Conform to the change of the name of a builtin. compiler/det_report.m: Improve the error message for cases when the determinism is incompatible with the selected tabling mechanism. compiler/compile_target_code.m: compiler/handle_options.m: compiler/options.m: Handle the new grade component. library/private_builtin.m: Provide a semipure analog of the imp predicate, a call to which makes predicates semipure rather than impure, for use in table_builtin.m. library/table_builtin.m: runtime/mercury_tabling_preds.h: Change the tabling primitives in the ways required by the changes to the tabling transformations. Group the primitives by the tabling methods they support, and change their names to reflect this. Change the implementation of each of the affected predicates to be nothing more than the invocation of a macro defined in the new header file runtime/mercury_tabling_preds.h. The objective of this change is to make it possible for table_gen.m to replace sequences of calls to predicates in table_builtin.m with a single extended foreign_proc goal whose body just invokes the corresponding macros in sequence. That change should improve performance by allowing the variables that flow from one tabling primitive to another to stay in x86 registers, instead of being copied to and from Mercury abstract machines registers, which on the x86 aren't real machine registers. Benchmarking in Uppsala verified that this is a major cost. Mark the foreign types used for tabling as can_pass_as_mercury_type; this was the intended use of that assertion. Make them private to the module, since the rest of the compiler can now handle this. Delete the implementations of the predicates for duplicate checking and for returning answers for completed subgoals. Profiling with gprof has shown their performance to be critical to the performance of minimal model tabling overall, and even with our recent changes, the compiler still can't create optimal C code for them. They are now implemented with handwritten code in mercury_minimal_model.c. library/term.m: Add two utility predicates for use by table_gen.m. library/Mmakefile: Since much of the implementation of table_builtin.m is now in runtime/mercury_tabling_preds.h, make its object files depend on that header file. runtime/mercury_conf_params.h: runtime/mercury_grade.h: Include MR_MINIMAL_MODEL_DEBUG when computing the grade. runtime/mercury_minimal_model.[ch]: Add handwritten code to implement the predicates declared as external in table_builtin.m. Conform to the new names of the suspension and completion predicates. Conform to the presence of debugging fields in tabling data structures only if MR_MINIMAL_MODEL_DEBUG is defined. Collect a lot more statistics than before. Reorder some functions. Instead of saving the whole generator stack each time, which the new statistics showed to have O(n^2) behavior on some benchmarks, save only the segment we need to save. runtime/mercury_tabling.h: Conform to the fact that loopcheck and memo predicates now have separate sets of status values, and import mercury_tabling_preds.h. runtime/mercury_tabling.c: runtime/mercury_hash_lookup_or_add_body.h: Move a huge macro out of mercury_tabling.c to the new file mercury_hash_lookup_or_add_body.h for ease of editing, and modify it to gather more statistics. Make the statistics report easier to read. runtime/Mmakefile: Mention mercury_tabling_preds.h and mercury_hash_lookup_or_add_body.h. runtime/mercury_wrapper.h: Provide a mechanism (--tabling-statistics in MERCURY_OPTIONS) that causes the runtime to print tabling statistics at the ends of executions, for use in benchmarking. doc/user_guide.texi: Document --tabling-statistics. (Minimal model tabling is not yet stable enough to be documented, which is why .dmm isn't documented either.) scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: scripts/mgnuc.in: Implement the new grade component. trace/mercury_trace.c: trace/mercury_trace_internal.c: Conform to changes in the runtime. tests/debugger/*.m: Avoid now invalid combinations of determinism and evaluation method. tests/debugger/*.exp: Conform to new goal paths in procedures transformed by tabling. tests/tabling/*.m: For tests which had predicate whose determinisms isn't compatible with the evaluation method, change the determinism if possible, and the evaluation method otherwise, if either is possible. Bring these tests up to date with our coding guidelines, since they may now appear in papers. tests/tabling/Mmakefile: Disable the tests whose combination of determinism and evaluation method is no longer supported, and in which neither one can be changed. tests/tabling/loopcheck_no_loop.{m,exp}: Make this test case tougher. tests/tabling/test_tabling: Make this script more robust in the face of different kinds of test case failures. tests/invalid/loopcheck.{m,err_exp}: tests/invalid/Mmakefile: Test that we get the expected error message for an invalid combination of determinism and evaluation method. The new test invalid/loopcheck.m is the old test tabling/loopcheck.m. tests/valid/Mmakefile: Use a more general pattern to test for minimal model grades, now that we also use .dmm as a grade component.	2004-05-31 04:13:39 +00:00
Zoltan Somogyi	cc508c83de	Perform frame optimization on nondet predicates. ... Estimated hours taken: 6 Branches: main Perform frame optimization on nondet predicates. The need for this was revealed by benchmarking in Uppsala, which initially showed Mercury to take three to five times as long as XSB on some tabling benchmarks. One major contributor was the fact that the predicate returning answers out of answer table was creating and destroying a nondet stack frame for every answer it returned. To make this change easier, make the representation of labels more reader friendly, classifying them primarily on whether they represent entry or internal labels, and only secondarily on the scope in which they represent valid references to the label. compiler/frameopt.m: Add a predicate to perform frame optimization on model_non predicates. This optimization involves separating the steps of creating the frame (done once) and setting the redoip (potentially done on every iteration). compiler/optimize.m: Invoke this new predicate. Reorder the arguments of predicates in this file, and the top level predicates of the optimizations it invokes, to allow the use of state variable notation. runtime/mercury_stacks.h: Provide macros for creating nondet stack frames that do not fill in the redoip slot. compiler/llds.m: Make the setting of redoip optional in mkframe operations. Make the representation of labels more reader friendly. compiler/layout_out.m: Change the representation of label layouts to enforce the invariant that these can refer only to internal labels. (The layout structures of entry labels are proc layout structures, whose design enforces the relevant invariant already.) compiler/jumpopt.m: Add an optimization that improves code that matches a new pattern: % Attempt to transform code such as % % if (Cond) L1 % goto L2 % % into % % if (! Cond) L2 % <code at L1> % % when we know the code at L1 and don't know the code at L2. The new frame optimization creates instances of this pattern, usually with L2 being do_fail. compiler/*.m: Minor diffs to conform to the changes above.	2004-05-23 23:14:37 +00:00
Zoltan Somogyi	c80d143cc8	The following change is only 98% complete, not 100%. ... Estimated hours taken: 120 Branches: main The following change is only 98% complete, not 100%. I am committing it in this state because (1) we pass many more test cases in deep profiling grade with it than without it, and (2) the double maintanance involved in fixing CVS conflicts is preventing me from doing the last 2%. Get the deep profiler to work for code that sets up to catch exceptions, which for the last year or more has included the compiler, and to get it almost working for code that actually catching exceptions. The basic problem is that code that throws exceptions will in general cause several calls to "return" without executing the exit or fail port codes that the deep profiling transformation inserted into their bodies, and this leaves the data structure being built by the deep profiling inconsistent. The solution uses the same approach as we have adopted for the debugger: have the code that handles the throwing of exceptions simulate a return from each call between the throw and the catch, updating the deep profiling data structures as needed. This requires us to be able to walk the stack at runtime not just in debugging grades but also in deep profiling grades. Since the debugger already has the mechanisms required for this, we reuse them. The procedure layouts used by the debugger were designed to have three segments: the procedure stack walk information, the procedure id, and the execution tracing information. We now modify this design to make the third segment contain two pointers: to the execution tracing information (for use by the debugger), and to the procedure's proc_static structure (for use by deep profiling). Each pointer will be null unless the pointed-to structure is required by compile-time options. This common use by the debugger and by deep profiling of the stack-walk structure and the procedure id structure (which deep profiling used to generate independently and possibly redundantly) required some rearrangement of the compiler's version of these data structures. To make this rearrangement simpler, this diff removes a capability that we theoretically supported but never used: turning on stack traces without turning on execution tracing and vice versa. After this diff, stack tracing is enabled if and only if either execution tracing or deep profiling is enabled. The diff also includes improvements in the debugging infrastructure for debugging deep profiling, which were necessary for the implementation of the rest of the changes. compiler/deep_profiling.m: The code in exception.m needs to know the locations of the variables that we would pass to the exit or fail port code, so it can simulate leaving the procedure invocation through the exception port. Without this information, throwing an exception leaves the deep profiling data structures of the procedure invocations between throw and catch in an inconsistent state. Deep_profiling.m creates these variables, but it doesn't know where they will be at runtime, so it records their identities; the code generator will allocate them stack slots and record the numbers of these stack slots for placement in the now expanded proc layout structures. Deep profiling used to generate static data structures separately from the HLDS, but since the code generator now needs access to them, we store their information in proc_infos in the HLDS. Instead of passing the addresses of proc_static structures to the deep profiling port procedures, pass the address of proc_layout structures, since the information about the identities of procedures are now stored not in the proc_static structure, but in the proc_layout structure that points to the proc_static structure. compiler/hlds_pred.m: compiler/layout.m: Move the definitions of the static data structures generated by deep profiling from layout.m to hlds_pred.m, to allow deep_profiling.m to store them in proc_infos. compiler/hlds_pred.m: compiler/rtti.m: Move the definition of rtti_proc_label from rtti.m to hlds_pred.m, since some of the new data structures in hlds_pred.m need it. Despite its name, the rtti_proc_label type doesn't contain any info that doesn't belong in the HLDS. Add some information to the rtti_proc_label type that is now needed by deep profiling, e.g. record determinisms instead of just code models. Record explicitly the outcome of some tests that used to be duplicated in more than one place in the compiler, e.g. for whether the procedure (as opposed to the predicate) is imported. Change some of the field names to be more precise about the field's meaning. compiler/code_gen.m: Transmit the contents of the deep profiling data structures stored in the proc_info by deep_profiling.m to continuation_info.m, together with the layout structures created for execution tracing and the identities of the variables needed for handling exceptions, when code generation for a procedure is complete. After the goal that generates these variables, save them to stack for use by the exception handler. compiler/hlds_goal.m: Add a feature to mark the goal that generates the deep profiling variables needed by the exception handler. compiler/hlds_llds.m: Add a utility predicate for new code in code_gen.m compiler/continuation_info.m: Hold the deep profiling information computed by code_gen.m for use by stack_layout.m. compiler/layout.m: compiler/layout_out.m: Update the definitions of the data structures describing procedure layouts, and the code writing them out, to reflect the use of some parts of procedure layouts by deep profiling as well as debugging. Change the layout structures generated by deep profiling to use rtti_proc_labels, which are backend independent, instead of proc_labels, which are specific to the LLDS backend. Conform to the changes in runtime/mercury_stack_layout.h. compiler/stack_layout.m: Generate the updated version of proc_layout structures. compiler/mercury_compile.m: compiler/global_data.m: Conform to the fact that deep profiling no longer generates layout structures separate from proc_infos. compiler/llds_out.m: Register proc_layout structures instead of proc_static structures for use by runtime/mercury_deep_profiling.c. compiler/options.m: compiler/handle_options.m: Rename the require_tracing option as exec_trace, since this more directly reflects its meaning. Instead of having --debug set both require_tracing and stack_trace, make it set (be the user-visible name of) just exec_trace; the value of stack_trace is implied. Turn off the specialization of deep profiling for self-tail-recursive procedures for now. Due to the changes made by this diff in the data structures involved in debugging, it cannot be debugged until this change has been installed. Handling the full language is more important than a specialization that reduces only stack space overheads, not runtime overheads. compiler/compile_target_code.m: Conform to the changes in options.m and runtime/mercury_grade.h. compiler/hlds_data.m: Replace the deep_profiling_proc_static cons_id, and its associated tag, to deep_profiling_proc_layout, since we now generate addresses of proc layout structures, not of proc_static structures. compiler/code_util.m: Simplify some code based on the new info in rtti_proc_labels. compiler/bytecode_gen.m: compiler/dependency_graph.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_code_util.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/proc_label.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/saved_vars.m: compiler/switch_util.m: compiler/unify_gen.m: Minor changes to conform to the change from deep_profiling_proc_static to deep_profiling_proc_layout, to the change in the structure of rtti_proc_labels, to the changes in types of layout.m, and/or to the new goal feature. deep_profiler/measurements.m: Reserve space for exception counts. deep_profiler/html_format.m: Add a column for exception counts. deep_profiler/profile.m: deep_profiler/read_profile.m: Rename the data structures referring to compiler generated unify, compare and index predicates to avoid misleading names: they are not the only compiler generated predicates. deep_profiler/read_profile.m: runtime/mercury_deep_profiling.c: Update the string that identifies deep profiling data files. This is necessary because the format has changed: it now includes information about exception port counts. library/exception.m: In deep profiling grades, execute the exception port code for every procedure invocation between a throw and a catch, using the procedure layout structures now generated by the compiler for every procedure. Rename the function involved to reflect its new, more general purpose. Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code. Indent C preprocessor directives and foreign_procs according to our coding standards. library/profiling_builtin.m: Change the parameters of the call port code procedures from proc_static to proc_layout. Reach the proc_static structure from the proc_layout structure when needed. Include the proc_layout structure in any messages from assertion failures. Add some conditionally compiled debugging code. Give some variables better names. runtime/mercury_type_info.h: runtime/mercury_builtin_types.c: Move the macros required to create the proc_static structures of unify and compare predicates from mercury_type_info.h to mercury_builtin_types.c, since the latter is the only file that needs them. Use the same macros for creating the proc_static structures of hand-written unify, compare and compare_reprentation predicates as for user defined predicates. This required changing their naming scheme. runtime/mercury_unify_compare_body.h: Conform to the new naming scheme. runtime/mercury_ho_call.c: Provide the mechanism for mercury_unify_compare_body.h to conform to the new naming scheme. Remove the definitions of the proc_static structures for hand-written unify, compare and compare_reprentation predicates, since these now have to be defined together with the corresponding proc_layout structures in mercury_builtin_types.c. runtime/mercury_builtin_types.[ch]: Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code, and add the required declarations first. Handle deep profiling of compare_representation as well as unify and compare predicates on builtin types. Handle deep profiling of compare_representation on user-defined types, since this is done entirely in the runtime, not by compiler generated predicates. runtime/mercury_builtin_types_proc_layouts.h: New header file containing the declarations of the proc layout structures of the unify, compare and index predicates of builtin types. Logically, these declarations belong in mercury_builtin_types.h, but putting them there causes problems for the linker; the details are explained in the file itself. runtime/Mmakefile: Add the new header file. runtime/mercury_minimal_model.[ch]: Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code, and add the required declarations first. runtime/mercury_grade.h: Replace the MR_REQUIRE_TRACING grade option with MR_EXEC_TRACING. Besides being better named, the MR_EXEC_TRACING option implies MR_STACK_TRACE. Besides the overall binary compatibility version number, add subsidiary version numbers for binary compatibility in deep profiling and debugging grades. These will make it easier to bootstrap changes (such as this) that affect binary compatibility only in such grades. runtime/mercury_trace_base.c: trace/mercury_trace.c: Conform to the new names of the configuration parameters. runtime/mercury_hand_compare_body.h: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_unify_compare_body.h: runtime/mercury_ho_call.c: tools/make_port_code: Pass proc_layout structures instead of proc_static structures to deep profiling port routines. runtime/mercury_conf_param.h: Make MR_DEEP_PROFILING as well as MR_EXEC_TRACING imply MR_STACK_TRACE, since deep profiling now needs stack tracing. (MR_STACK_TRACE needs to be set in this file, because tests in this file depend on knowing its value, and this file is among the first files included (in this case indirectly) in mercury_imp.h.) Document the macros controlling the debugging of deep profiling. Enable printing of label names when the relevant deep profiling debugging macro is set. runtime/mercury_debug.c: runtime/mercury_deep_rec_depth_actions.h: runtime/mercury_deep_rec_depth_body.h: runtime/mercury_exception_catch_body.h: Get to proc_statics via proc_layouts. runtime/mercury_deep_call_port_body.c: runtime/mercury_deep_leave_port_body.c: Get to proc_statics via proc_layouts. Allow the debugger to disable deep profiling in Mercury code that is part of the debugger, not of the user program being executed. Add some more assertions. runtime/mercury_engine.[ch]: Add a new debugging flag that controls at runtime whether we generate a human readable Deep.debug equivalent to the binary Deep.data files. (We already had a mechanism for controlling this at compile time, but this isn't flexible enough.) runtime/mercury_wrapper.c: Allow this new debugging flag to be set from MERCURY_OPTIONS. runtime/mercury_deep_profiling.[ch]: Respect this new debugging flag. Update the hand-written proc_static structures representing the runtime system. Print out addresses of proc_layout as well as proc_static structures when assertions fail. Add a field to the measurement structure for exception port counts, and write out this field with the other port counts. Remove procedure id information from proc_static structures, deep profiling now uses the procedure id in the proc_layout structure. Add to proc_static structures fields that specify where, if anywhere, the variables needed by exception.m to executed the exception port code are in the procedure's stack frame. Define a global flag that allows the debugger to disable deep profiling in Mercury code that is part of the debugger, not of the user program being executed. Increase type safety by providing two versions of the function for registering proc_layouts, one for the proc_layout structures of user-defined predicates and one for unify, compare and index predicates. Fix a bug that occurs only if MR_DEEP_PROFILING_EXPLICIT_CALL_COUNTS is defined (which it usually isn't): the initial call count was wrong. runtime/mercury_deep_profiling_hand.h: Fix a bug: the handwritten code saving deep profiling variables was saving them in slots that didn't belong to the relevant stack frame. Update to conform to the modified definitions of proc_static structures and the fact that we now reach them via proc_layout structures. runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: Fix the other side of the bug in mercury_deep_profiling_hand.h by reserving the right number of stack slots in the stack frames of the various modes of exception__catch. Make it harder to make the same bug in the future by getting the needed info from the place in mercury_stacks.h that defines the structure of the relevant stack frame. runtime/mercury_proc_id.h: Rename the procedure id structure fields referring to compiler generated unify, compare and index predicates: they are not the only compiler-generated predicates. runtime/mercury_stack_layout.h: Change procedure layout structures to allow them to be used for deep profiling as well as for debugging, as described in the prologue above. We don't need the capability to support label layout structures with links to misnamed proc layout structures, and supporting it is inconvenient, so delete the capability. runtime/mercury_debug.c: runtime/mercury_deep_profiling_hand.h: runtime/mercury_layout_util.c: runtime/mercury_ml_expand_body.h: runtime/mercury_stack_trace.c: runtime/mercury_types.h: trace/mercury_trace_external.c: Conform to the new names of the procedure id structure fields. runtime/mercury_std.h: Add some more arities for MR_PASTE for use in some of the modified modules in the runtime. trace/mercury_trace_internal.c: Disable deep profiling actions in Mercury code that is part of the debugger, not of the program being debugged. scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make changes parallel to the ones in runtime/mercury_grade.h: delete --stack-trace as an independent option, and make --debug set its own option, not --require-tracing. scripts/canonical_grade.sh-subr: scripts/final_grade_options.sh-subr: scripts/c2init.in: scripts/mgnuc.in: scripts/ml.in: Conform to the changes in grade options for debugging and for deep profiling. tools/bootcheck: If Mmake.stage.{browser,deep,library,runtime,trace}.params exist, copy them to become the file Mmake.$dir.params in stage2/$dir (where dir is derived from the name of the original file in the obvious way). This allows more flexibility in the creation of the stage2; for example, it allows some directories (e.g. runtime or library) to be compiled with more debugging than other directories (e.g. compiler). This may be required because compiling all directories with lots of debugging may cause the linker to thrash. Add an option, --disable-debug-libs, that clobbers the libraries that should be linked in only in debugging grades. To conserve disk space, remove Deep.data files created by the bootcheck by default. Add an option, --keep-deep-data, to preserve these files. Use a consistent mechanism (test -f) for testing the existence of all files whose existence is tested. When recording modification times, record the modification times of some more files. tests/hard_coded/Mmakefile: In deep profiling grades, disable the test cases that we don't now pass in such grades, and document the reasons for their failure. Fix the misclassification of the write_binary test case.	2004-05-19 04:00:01 +00:00
Zoltan Somogyi	5181713f10	Add macros that allow the compiler to generate smaller .c files, especially ... Estimated hours taken: 0.5 Branches: main Add macros that allow the compiler to generate smaller .c files, especially but not exclusively with debugging enabled. runtime/mercury_calls.h: Add a noprof_ equivalent of the only call macro that didn't already have one. runtime/mercury_goto.h: Add macros that declare labels without mercury__ prefixes in their arguments, and macros that declare more than one label at a time. Likewise add macros for use in the construction of lists of label layout structures that do not need mercury__ prefixes and can expand to the addresses of more than one layout structure. runtime/mercury_heap.h: runtime/mercury_tags.h: Add variants of existing macros that provide MR_mktag() wrappers around tags, so they don't have to appear in the macro invocation. runtime/mercury_stacks.h: Allow stackvars and framevars to be referred to by shorter names. Simplify the implementation and clarify the documentation of some existing macros. runtime/mercury_stack_layout.h: Add macros that declare layout structures without mercury__ prefixes in their arguments, and macros that declare more than one layout structure at a time.	2004-04-06 22:29:41 +00:00
Zoltan Somogyi	7fda11f65a	Our existing mechanism for detecting when the failure out of a negated context ... Estimated hours taken: 8 Branches: main Our existing mechanism for detecting when the failure out of a negated context is due to the suspension of a consumer, and not to genuine failure was flawed in two ways. First, it did not consider all-solutions predicates to be negated contexts; second, in some circumstances it could rely on out-of-date data. library/std_util.m: Wrap predicates called in contexts where all solutions are required with calls to the routines wrapping negated contexts. Since the routines have empty definitions in all grades except minimal model grades, there is extra overhead only in minimal model grades. runtime/mercury_stacks.[ch]: When processing suspensions of consumers in a possibly negated context and checking that their generators are complete, disregard consumers that have logically been deleted together with their generators when execution reached the end of the committed-choice contexts in which they were created. Without this change, the generator_in_commit test case would get an unnecessary abort. Register consumers instead of generators in pneg stack entries, and make the generator reachable from the consumer, instead of registering just the consumer's generator. The old arrangement hid information that could be useful during debugging. runtime/mercury_minimal_model.c: Conform to the change to the mercury_stacks module. Rename "pickling" to pruning right branches, since this expresses the intent of the operation more directly. Fix a bug in the printing of the addresses of the redoip slots of pruned stack frames. Delete unneeded code. tests/tabling/Mmakefile: Record the fact that we now get the expected error in the consumer_in_solutions test case. tests/tabling/consumer_in_solutions.{exp,exp2}: Update the expected output in this test case. The old contents of the .exp file is the ideal expected output, but it is not achievable with our current approach to implementing minimal model tabling. It has therefore been moved to the new .exp2 file. tests/tabling/generator_in_commit.{m,exp}: Make this test case do less computation, to make it more useful in tracking down errors. The new version still tests everything the old version tested, just not so many times.	2004-03-20 05:51:35 +00:00
Zoltan Somogyi	8b9d436cbb	More improvements for minimal model tabling. ... Estimated hours taken: 12 Branches: main More improvements for minimal model tabling. runtime/mercury_engine.[ch]: Provide a debug flag to control the printing of debug stack slots in nondet stack dumps. runtime/mercury_stack_trace.[ch]: Provide a mechanism that allows a dump of the nondet stack to print the principal debugging stack slots of the stack frames of procedures that were compiled with debugging, to help debug problems where these are overwritten during stack segment saves/restores. Add a mechanism for limiting the output of a nondet stack trace to a segment of the nondet stack. runtime/mercury_minimal_model.[ch]: Limit the output of a diagnostic nondet stack trace to just the segment being saved or restored. Provide a label layout structure for the entry point of the suspend predicate, since this is necessary for correct nondet stack traces at suspensions and resumptions. Store the layout structure of the top nondet stack frame with each saved state, to allow the saved nondet stack segment to be dumped at resumptions as well as suspensions. Fix an old bug: when extending a saved stack segment, use the same algorithm for determining its lower bound as when the stack segment was created in the first place. Factor out some repeated definitions. Note problems to be fixed later. Improve debugging output. runtime/mercury_stacks.[ch]: Move the documentation of the generator stack, the cut stack and the pneg stack from the source file to the header file, and expand it considerably. Make the routines for printing entries of these stacks generate more consistently formatted output. Simplify some code. runtime/mercury_stack_layout.h: Provide a macro for use by mercury_minimal_model.c. runtime/mercury_trace_base.[ch]: Save and restore the global variables holding event numbers, call sequence numbers and call depths across debugging Mercury code. We already used to do this for Mercury code invoked by the debugger, but now that we can invoke Mercury code to print the values of variables as diagnostics from within the suspend and resume predicates *outside* the debugger, we need to do it more generally. trace/mercury_trace.c: Fix a bug: provide the layout structure of the current procedure to the diagnostic routines for minimal model tabling even if the debugger doesn't stop at that procedure. trace/mercury_trace_internal.c: Add two new mdb commands to help debug minimal model tabling. The "mm_stack" command has the same effect as the existing commands "gen_stack", "cut_stack" and "pneg_stack" executed in sequence. The "debug_vars" command prints the counters for event numbers, call sequence numbers and call depths, both from their global variables and their saved copies, for debugging problems where they are overwritten, such as the one fixed by the changes to mercury_trace_base.[ch] above. Reorder some code for consistency. trace/mercury_trace_util.[ch]: Add a function to implement the "debug_vars" command. doc/user_guide.texi: Document the new mdb commands. doc/mdb_categories: Add the new mdb commands to the list of developer commands, as well some others previously left out. tests/debugger/mdb_command_test.inp: Test the documentation of the new mdb commands. tests/tabling/combine.m: Change the code of this test case to what was intended, so that it now matches the old expected output. tests/tabling/completed_consumer_in_solutions.{m,exp}: New test case, an easier version of consumer_in_solutions. tests/tabling/consumer_in_commit.{m,exp}: Extend this test case and update the expected output; we can execute both the original code and the extension without runtime exceptions. tests/tabling/seq2.m: Fix Kostis's new test case. tests/tabling/seq4.exp: Fix the expected output of Kostis's new test case. tests/tabling/Mmakefile: Enable the new test cases, and some old test cases that we now pass.	2004-03-12 06:02:19 +00:00
Fergus Henderson	ddab616d35	Some minor documentation tweeks. ... Estimated hours taken: 0.25 Branches: main Some minor documentation tweeks. runtime/mercury_conf_param.h: Delete comment about MR_NATIVE_GC not working, since it does work now, at least in grade hlc.agc (there are still some problems with asm_fast.agc). runtime/mercury_stacks.h: Add a pointer to the documentation in compiler/notes/failure.html.	2003-11-05 08:51:20 +00:00
Fergus Henderson	c743626923	Various bug fixes for accurate GC in LLDS grades: ... Estimated hours taken: 4 Branches: main Various bug fixes for accurate GC in LLDS grades: runtime/mercury_wrapper.c: Fix two bugs in my last change: - use MR_NATIVE_GC rather than the non-existent MR_ACCURATE_GC - use %lf rather than %f when calling scanf() for a double runtime/mercury_accurate_gc.c: - Fix some bugs with traversing the nondet stack. - Make sure that we round the active heap size up to a multiple of the page size, otherwise mprotect() won't work. - Avoid some casts by using type `MR_Code **' rather than `MR_Word *' for the saved_success_location variable. - Comment out some unused code. runtime/mercury_stacks.h: Add MR_curfr_slot_addr(), which is like MR_curfr_slot() except that it returns the slot's address, for use by mercury_accurate_gc.c. (Using "&MR_curfr_slot(...)" results in an "invalid lvalue" error from GCC, despite the use of MR_LVALUE_CAST in its definition.) runtime/mercury_stack_trace.h: Add some comments. runtime/mercury_stack_trace.c: Fix some incorrect indentation. compiler/stack_layout.m: Fix a cut-and-paste error.	2003-10-22 08:50:15 +00:00
Zoltan Somogyi	9489e15291	*** empty log message ***	2003-05-02 21:44:17 +00:00
Zoltan Somogyi	168500343c	This change adds new facilities for debugging minimal model tabling, and ... Estimated hours taken: 160 Branches: main This change adds new facilities for debugging minimal model tabling, and has several bug fixes found with the aid of those facilities. Most of the diff affects the behavior of the system only in minimal model grades and/or when debugging flags are defined. compiler/ite_gen.m: In minimal model grades, surround the conditions of if-then-elses with calls to three functions. These functions detect when a condition fails due to one or more suspensions, and abort the program. (After resumptions, the condition may actually have solutions, but by then the computation has committed to the wrong path.) compiler/table_gen.m: Change the program transformation for model_non predicates to use a switch instead of nested if-then-elses, to avoid the overhead of wrapping the condition. The version with switches is also a bit easier to debug. The transformation for model_det and model_semi predicates stays as before, because for such predicates finding the status (which we want to switch on) requires computation, not just a lookup. Switch to state variable syntax in the affected predicates. Make the error message for an internal error in loopcheck predicates more precise. Mark the code fragments that modify tabling data structures as impure and code fragments that examine tabling data structures as semipure. runtime/mercury_stacks.[ch]: Implement the new stack of possibly negated contexts that we use to detect false failures due to suspensions in negated contexts. Fix a bug: don't refer to MR_cut_stack[-1]. Shorten the name of the generator stack. runtime/mercury_context.[ch]: runtime/mercury_memory.c: runtime/mercury_wrapper.[ch]: Allocate memory for the new stack of possibly negated contexts. Use the shortened name of the generator stack. runtime/mercury_regorder.h: Allocate a pointer for the new stack of possibly negated contexts. runtime/mercury_minimal_model.[ch]: A new module holding the part of mercury_tabling.[ch] that is specific to minimal model tabling. This version contains tools to help debugging of minimal model tabling, as well as some bug fixes found with the aid of those tools. runtime/mercury_tabling.[ch]: Remove the code moved to mercury_minimal_model.[ch], and add the code moved here from trace/mercury_trace_internal.c. Add prefixes to a bunch of structure fields to make it easier to read code accessing those fields. Add mechanisms to allocate and copy tabling structures with type safety. runtime/mercury_imp.h: #include the new header file, if it is needed. runtime/Mmakefile: Mention the new module, and fix sortedness errors. runtime/mercury_stack_trace.c: Fix a bug that sometimes caused stack traces to abort in minimal model grades: they were trying to get layout information from labels that do not have them, such as do_fail. If MR_TABLE_DEBUG is defined, print the locations of stack frames when doing stack dumps. runtime/mercury_trace_base.h: Export to mercury_stack_trace.c the labels that we use to let the debugger get control at redos and fails, since they don't have layout information. runtime/mercury_types.h: Move typedefs here from mercury_tabling.h, and add typedefs for some newly added types. runtime/mercury_engine.[ch]: Add a table mapping debugging flags to their offsets in the MR_debugflag array, for use in the debugger. runtime/mercury_misc.c: Make the formatting of det stack pointers the same as nondet stack pointers in debugging output. runtime/mercury_debug.[ch]: Add conditionally compiled debugging output when creating temp frames on the nondet stack. library/table_builtin.m: Conform to the new names of some fields. Add a predicate to return the status of a subgoal. Add conditionally compiled debugging code. library/Mmakefile: Make table_builtin.m depend on runtime/mercury_minimal_model.h. trace/mercury_trace.c: Conform to the new names of some fields. trace/mercury_trace_internal.c: Add two new mdb commands, to print the cut stack and the new possibly negated context stack. Add two new mdb commands to print a subgoal and a consumer. Move some of the code to print tabling-related data structures to runtime/mercury_tabling.[ch]. Add a new mdb command to report the values of debugging flags and to set and clear them. Previously, one had to turn on these debugging flags with environment variables, which were problematic because they turned on diagnostic printouts even in Mercury programs that *weren't* being debugged, such as the Mercury compiler when being used to generate the program to be debugged. Now the flags can be turned on from a .mdbrc file, which eliminates much setting and unsetting of environment variables. doc/user_guide.tex: Document the new mdb commands. tests/debugger/mdb_command_test.inp: Test the documentation of the new mdb commands. tests/debugger/completion.exp: Expect the new commands in the command completion test. tests/debugger//nondet_stack.exp*: Expect the new format of det stack pointers. tests/debugger/all_solutions.exp3: tests/debugger/exception_value.exp3: tests/debugger/declarative/catch.exp3: tests/debugger/declarative/ho5.exp3: tests/debugger/declarative/throw.exp3: New expected test cases for use in minimal model grades. They differ from existing expected output files only in the precise phrasing of error messages. tests/debugger/declarative/Mmakefile: Disable the untraced_subgoal test case in .mm grades, since we don't pass it yet. tests/tabling/Mmakefile: Enable the mday test case, now that we pass it.	2003-03-18 16:39:01 +00:00
Zoltan Somogyi	cdb12419c1	Make the MR_based_stackvar and MR_stackvar macros treat MR_sp as ... Estimated hours taken: 0.2 Branches: main runtime/mercury_stacks.h: Make the MR_based_stackvar and MR_stackvar macros treat MR_sp as pointing not to the first free word on the det stack, but to the last used word. MR_maxfr already points to the last used word on the nondet stack. Eliminating this unnecessary difference between them should make it easier to write code to perform surgery on stack segments. (The existing code working with stack segments is already flawed; it will be fixed in other changes.) Note that neither the code in mercury_context.[ch] that initializes MR_sp (and the context structure field that holds saved values of MR_sp) to point to the bottom of the detstack zone nor the code in mercury_overflow.h that compares MR_sp against the top of the detstack zone required changes after this. To avoid cache collisions, we don't use the bottom part of the detstack zone anyway; it doesn't matter exactly how many words we leave unused there. The overflow check code (which usually isn't enabled) was overly conservative; it is now exactly right. runtime/mercury_grade.h: Since the change to mercury_stacks.h affects how the C compiler treats .c files generated by mmc in all LLDS grades, increment the binary compatility version number.	2002-11-22 03:17:53 +00:00
Zoltan Somogyi	d95abc7fb0	Fix formatting in some macros. ... Estimated hours taken: 0.1 Branches: main runtime/mercury_stacks.h: Fix formatting in some macros.	2002-11-06 06:54:11 +00:00
Mark Brown	301994f357	A more robust version of my previous bugfix. ... Estimated hours taken: 0.25 Branches: main A more robust version of my previous bugfix. runtime/mercury_stacks.h: Save the value of MR_trace_from_full in the exception struct when it is created at the start of builtin_catch. library/exception.m: Restore the value of MR_trace_from_full from the exception struct, before calling the exception handler.	2002-10-10 17:56:06 +00:00
Zoltan Somogyi	0199b58905	Fix bad MR_ in comment. ... Estimated hours taken: 0.1 Branches: main runtime/mercury_stacks.h: Fix bad MR_ in comment.	2002-08-19 07:14:56 +00:00
Zoltan Somogyi	2aa84cf86d	In minimal model grades, add an extra slot to nondet stack frames containing ... Estimated hours taken: 1 Branches: main In minimal model grades, add an extra slot to nondet stack frames containing the value of MR_sp when the stack frame is created. This will be necessary in future changes that manipulate stack segments. runtime/mercury_stacks.h: Add the extra slot in nondet stack frames in minimal model grades. Rename the similar slot in temp frames from MR_detfr_slot to MR_tmp_detfr_slot; the new slot is MR_table_detfr_slot. Decrease the level of indentation of macro bodies where this was becoming a problem. runtime/mercury_agc_debug.c: runtime/mercury_stack_trace.c: Conform to the changes in mercury_stacks.h. runtime/mercury_stack_trace.c: Switch to four-space indentation to cope with the increased demands on indentation.	2002-08-19 06:42:09 +00:00
Simon Taylor	c66cea0665	Add MR_ prefixes to uses of configuration macros. ... Estimated hours taken: 2.5 Branches: main Add MR_ prefixes to uses of configuration macros. Bootcheck now succeeds with MR_NO_CONF_BACKWARDS_COMPAT. Mmake.common.in: Define MR_NO_CONF_BACKWARDS_COMPAT when checking for namespace cleanliness. RESERVED_MACRO_NAMES: Remove the configuration macros. runtime/mercury_conf_bootstrap.h: Remove a duplicate definition of BOXED_FLOAT. configure.in: */*.c: */*.h: */*.m: Add MR_ prefixes.	2002-02-13 09:56:49 +00:00
Zoltan Somogyi	678fa1075f	Add a capability for measuring statistics about the stack frame usage ... Estimated hours taken: 6 Branches: main Add a capability for measuring statistics about the stack frame usage of a program. configure.in: Find out the symbolic names of the max values for the 16 and 32 bit integer types. runtime/mercury_conf.h.in: Include MR_{UINT,INT}_LEAST{16,32}_MAX among the macros whose values are determined by autoconfiguration. runtime/mercury_conf_param.h: Document MR_STACK_FRAME_STATS as a macro whose definition causes the program to collect statistics on stack frame sizes. Fix an obsolete reference: PARALLEL was renamed MR_THREAD_SAFE a long time ago. Document the incompatibility between MR_THREAD_SAFE and the statistics collection flags. runtime/mercury_stacks.h: If MR_STACK_FRAME_STATS is defined, then record statistics every time we create a stack frame. runtime/mercury_stacks.c: Define the global variables and functions needed for stack frame statistics. runtime/mercury_heap_profile.h: runtime/mercury_dword.h: Move the macros for managing 64-bit counters from mercury_heap_profile.h to a new header file, mercury_dword.h, since mercury_stacks.h now needs such counters too. Rewrite the macros to make fewer assumptions, using MR_int_least64_t and MR_int_least32_t instead of "long long" and "int". Add expression-like forms of some of the macros for use in mercury_stacks.h. Rename the type MR_dword as MR_Dword. runtime/mercury_heap_profile.c: #include the new header file. runtime/mercury_prof.c: Conform to the change from MR_dword to MR_Dword. runtime/Mmakefile: Add the new header file to the list of header files. runtime/mercury_wrapper.c: If MR_STACK_FRAME_STATS is defined, initialize the stack frame stats before execution starts and write out the statistics when execution ends. tools/speedtest: Add an option that when set, causes the script to report stack frame stats for each variant being tested.	2001-12-27 07:25:25 +00:00
Zoltan Somogyi	04e614485d	Implement deep profiling; merge the changes on the deep2 branch back ... Estimated hours taken: 500 Branches: main Implement deep profiling; merge the changes on the deep2 branch back onto the trunk. The main documentation on the general architecture of the deep profiler is the deep profiling paper. doc/user_guide.texi: Document how to use the deep profiler. deep_profiler: deep_profiler/Mmakefile: A new directory holding the deep profiler and its mmakefile. Mmakefile: Add targets for the new directory. Add support for removing inappropriate files from directories. deep_profiler/interface.m: The deep profiler consists of two programs: mdprof_cgi.m, which acts as a CGI "script", and mdprof_server.m, which implements the server process that the CGI script talks to. Interface.m defines the interface between them. script/mdprof.in: A shell script template. ../configure uses it to generate mdprof, which is a wrapper around mdprof_cgi that tells it how to find mdprof_server. deep_profiler/mdprof_cgi.m: The CGI "script" program. deep_profiler/mdprof_server.m: The top level predicates of the server. deep_profiler/profile.m: The main data structures of the server and their operations. deep_profiler/read_profile.m: Code for reading in profiling data files. deep_profiler/startup.m: Code for post-processing the information in profiling data files, propagating costs from procedures to their ancestors and performing various kinds of summaries. deep_profiler/server.m: Code for responding to requests from the CGI script. deep_profiler/cliques.m: Code to find cliques in graphs. deep_profiler/array_util.m: deep_profiler/util.m: Utility predicates. deep_profiler/dense_bitset.m: An implementation of (part of) the set ADT with dense bit vectors. deep_profiler/measurements.m: Operations on profiling measurements. deep_profiler/timeout.m: An implementation of a timeout facility. deep_profiler/conf.m: Functions that depend on autoconfigured settings. configure.in: Find out what command to use to find the name of the local host. Install deep profiling versions of the standard library along with the other profiling versions. runtime/mercury_conf.h.in: Add some macros for deep_profiler/conf.m to use. library/profiling_builtin.m: runtime/mercury_deep_call_port_body.h: runtime/mercury_deep_leave_port_body.h: runtime/mercury_deep_redo_port_body.h: A new library module that implements deep profiling primitives. Some of these primitives have many versions, whose common code is factor is factored out in three new include files in the runtime. compiler/deep_profiling.m: New module to perform the program transformations described in the paper. compiler/notes/compiler_design.html: Document the new compiler module. compiler/mercury_compiler.m: Invoke the new module in deep profiling grades. Allow global static data to be generated by deep_profiling.m. compiler/options.m: Add options to turn on deep profiling and (for benchmarking purposes) control its implementation. Add an optiooption disable tailcall optimization in the LLDS backend, to help benchmarking deep profiling. compiler/jumpopt.m: compiler/optimize.m: Obey the option to disable tailcalls. compiler/handle_options.m: Handle the implications of deep profiling. compiler/modules.m: In deep profiling grades, automatically import profiling_builtin.m. compiler/prog_util.m: doc/Makefile: library/library.m: Handle the new builtin module. compiler/export.m: In deep profiling grades, wrap deep profiling code around exported procedures to handle the "unscheduled call" aspects of callbacks to Mercury from the foreign language. compiler/higher_order.m: profiler/demangle.m: util/demangle.c: When creating a name for a higher-order-specialized predicate, include the mode number in the name. compiler/add_trail_ops.m: compiler/type_util.m: Move c_pointer_type from add_trail_ops to type_util, so it can also be used by deep_profiling.m. compiler/hlds_goal.m: Add a new goal feature that marks a tail call, for use by deep_profiling.m. compiler/hlds_pred.m: Add a new field to proc_info structures for use by deep_profiling.m. Add a mechanism for getting proc_ids for procedure clones. Remove next_proc_id, an obsolete and unused predicate. compiler/hlds_data.m: Add a new cons_id to refer to the proc_static structure of a procedure. compiler/bytecode_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/switch_util.m: compiler/unify_gen.m: Trivial changes to handle the new cons_id, goal feature and/or proc_info argument. compiler/rtti.m: Add a utility predicate for extracting pred_id and proc_id from an rtti_proc_label, for use by hlds_out.m compiler/layout.m: compiler/layout_out.m: compiler/llds.m: compiler/llds_common.m: Add support for proc_static and call_site_static structures. compiler/layout_out.m: compiler/llds_out.m: Add code for the output of proc_static structures. compiler/code_util.m: Make code_util__make_proc_label_from_rtti a function, and export it. util/mkinit.c: compiler/llds_out.m: compiler/layout.m: compiler/modules.m: Add support for a fourth per-module C function, for writing out proc_static structures (and the call_site_static structures they contains). Since proc_static structures can be referred to from LLDS code (and not just from other static structures and compiler-generated C code), reorganize the declarations of static structures slightly. Change the schema for the name of the first per-module C function slightly, to make it the addition of the fourth function easier. The scheme now is: mercury__<modulename>__init mercury__<modulename>__init_type_tables mercury__<modulename>__init_debugger mercury__<modulename>__write_out_proc_statics Improve formatting of the generated C code. library/*.m: runtime/mercury.c: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_tabling.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: trace/mercrury_trace.[ch]: trace/mercrury_trace_declarative.c: trace/mercrury_trace_external.c: trace/mercrury_trace_internal.c: Conform to the new scheme for initialization functions for hand-written modules. compiler/mercury_compile.m: library/benchmarking.m: runtime/mercury_conf_param.h: runtime/mercury.h: runtime/mercury_engine.c: runtime/mercury_goto.c: runtime/mercury_grade.h: runtime/mercury_ho_call.c: runtime/mercury_label.[ch]: runtime/mercury_prof.[ch]: Add an MR_MPROF_ prefix in front of the C macros used to control the old profiler. compiler/handle_options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make deep profiling completely separate from the old profiling system, by making the deep profiling grade independent of MR_MPROF_PROFILE_TIME and the compiler option --profile-time. library/array.m: library/builtin.m: library/std_util.m: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_compare_body.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of hand-written unification and comparison procedures. Make the reporting of array bounds violations switchable between making them fatal errors, as we currently, and reporting them by throwing an exception. Throwing an exception makes debugging code using arrays easier, but since exceptions aren't (yet) propagated across engine boundaries, we keep the old behaviour as the default; the new behaviour is for implementors. runtime/mercury_deep_profiling_hand.h: New file that defines macros for use in Mercury predicates whose definition is in hand-written C code. library/exception.m: runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of the various modes of builtin_catch. Provide a function that C code can use to throw exceptions. library/benchmarking.m: library/exception.m: library/gc.m: library/std_util.m: runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_overflow.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_thread.c: runtime/mercury_wrapper.c: Add prefixes to the names of the fields in the engine and context structures, to make code using them easier to understand and modify. runtime/mercury_deep_profiling.[ch]: New module containing support functions for deep profiling and functions for writing out a deep profiling data file at the end of execution. runtime/mercury_debug.[ch]: Add support for debugging deep profiling. Add support for watching the value at a given address. Make the buffered/unbuffered nature of debugging output controllable via the -du option. Print register contents only if -dr is specified. runtime/mercury_goto.h: runtime/mercury_std.h: Use the macros in mercury_std.h instead of defining local variants. runtime/mercury_goto.h: runtime/mercury_stack_layout.h: runtime/mercury_stack_trace.c: runtime/mercury_tabling.c: trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Standardize some of the macro names with those used in the debugger paper. runtime/mercury_heap.h: Add support for memory profiling with the deep profiler. runtime/mercury_prof.[ch]: runtime/mercury_prof_time.[ch]: Move the functionality that both the old profiler and the deep profiler need into the new module mercury_prof_time. Leave mercury_prof containing stuff that is only relevant to the old profiler. runtime/mercury_prof.[ch]: runtime/mercury_strerror.[ch]: Move the definition of strerror from mercury_prof to its own file. runtime/mercury_wrapper.[ch]: Add support for deep profiling. Add suppory for controlling whether debugging output is buffered or not. Add support for watching the value at a given address. runtime/Mmakefile: Mention all the added files. scripts/mgnuc.in: Add an option for turning on deep profiling. Add options for controlling the details of deep profiling. These are not documented because they are intended only for benchmarking the deep profiler itself, for the paper; they are not for general use. tools/bootcheck: Compile the deep_profiler directory as well as the other directories containing Mercury code. Turn off the creation of deep profiling data files during bootcheck, since all but one of these in each directory will be overwritten anyway. Add support for turning on --keep-objs by default in a workspace. tools/speedtest: Preserve any deep profiling data files created by the tests. trace/mercury_trace.c: Trap attempts to perform retries in deep profiling grades, since they would lead to core dumps otherwise. util/Mmakefile: Avoid compile-time warnings when compiling getopt. tests/*/Mmakefile: tests/*/*/Mmakefile: In deep profiling grades, switch off the tests that test features that don't work with deep profiling, either by design or because the combination hasn't been implemented yet.	2001-05-31 06:00:27 +00:00
Zoltan Somogyi	4da8c2a500	Address Fergus's late review comments on a previous change. ... Estimated hours taken: 1.5 Address Fergus's late review comments on a previous change. browser/dl.m: Allocate closures on the heap. runtime/mercury_heap.h: Add a mechanism to allocate C structures on the heap. runtime/mercury_stacks.h: runtime/mercury_types.h: Move a macro from mercury_stacks.h to mercury_types.h, to give mercury_heap.h access to it.	2001-02-21 05:53:43 +00:00
Levi Cameron	7098645a3a	More work on the bytecode interpreter. ... With these changes, it now passes all tests/general/* test cases except those with floats. Changes to the compiler: - Added extra argument to test instruction (string comparisons were being treated as integer comparisons; properly deals with different atomic type unifications now) - Changed bytecode stub functions Changes to the bytecode interpreter: - Cleaned up comments - Forked part of mb_machine to mb_exec - Added support for submodules - Added support for nondet procedures - Added support for cc_xxx procedures - Finished higher order calls - Added (very basic) debug interface - Added support for type information - Added memory corruption checking - Changed machine state dump formatting - Fixed bug in nested switches - Resolved builtin__unify and builtin_compare failures - Modified bytecode tags generation so .c & .m tag files are separate - Header usage rationalised Changes to test suite: - Added test cases for the bytecode interpreter. - More work on the bytecode interpreter. bytecode/Mmakefile: Modified bytecode tags generation so .c & .m tag files are separate. mb_machine split into mb_exec. test file renamed to simple.m (copy over tests/simple??.m to test). bytecode/TODO: Updated. bytecode/mb_basetypes.h: Removed redundant MB_WORD_BITS (use MR_WORDBITS instead). bytecode/mb_bytecode.h: bytecode/mpb_bytecode.c: Formatting changes Third test instruction argument added. bytecode/mb_disasm.h: bytecode/mb_disasm.c: Formatting changes. Third test instruction argument added. Added MB_FMT_INTWIDE. bytecode/mb_exec.h: bytecode/mb_exec.c: bytecode/mb_machine.h: bytecode/mb_machine.c: mb_machine* split into mb_exec* and mb_machine*. Almost all instructions now work (see important changes above). bytecode/mb_interface.h: bytecode/mb_interface.c: Added nondet stub functions. Added functions to lookup builtin compiler procedures: do_redo, do_fail, __unify, __compare. Removed old debugging code. Stack layout changed to support nondet procedures. bytecode/mb_interface_stub.c: bytecode/mb_interface_stub.h: Split off bare minimum of includes for bytecode stubs. Added nondet stubs. bytecode/mb_machine_show.c: Made code cleaner (added subfunctions for MB_show_state). Added variable names to machine state dump. bytecode/mb_mem.h: bytecode/mb_mem.c: Added limited memory corruption checking. bytecode/mb_module.h: bytecode/mb_module.c: Swapped order of temps & vars on stack. Fixed nested switches causing random crashes. Added nested module support. bytecode/test/simple??.m: Various test files - just to check that it doesn't crash. (Most do not output anything & must be verified by stepping through manually). compiler/bytecode.m: compiler/bytecode_gen.m: Added extra argument to test instruction (otherwise string comparisons would be treated as integer comparisons). compiler/code_gen.m: Changed call structure name in bytecode stub to resolve issues with illegal characters in C structure names. Changed bytecode stub header file name. runtime/mercury_conf_param.h: Added option to allow generation of labels in label table for bytecode lookup. runtime/mercury_stacks.h: Added comment clarifying indexing convention.	2001-02-19 02:07:16 +00:00
Fergus Henderson	499ffadbc3	Connect the Mercury compiler to the GCC back-end. ... Estimated hours taken: 120 Connect the Mercury compiler to the GCC back-end. These changes give us a version of the Mercury compiler which compiles to assembler without going via any intermediate files. This version generates GCC's `tree' data type, and then calls functions in the GCC middle-end to convert that to GCC's RTL (Register Transfer Language) and to invoke the rest of the GCC middle-end and back-end to compile it to assembler. RATIONALE The main advantage is improved compilation speed. (The improvement is not huge, since the current front-end is so slow, but improving the speed of the back-end increases the incentive to improve the speed of the front-end, since it means that any increases in the speed of the front-end will get bigger overall speedups.) Another advantage is that it gives us more opportunity to give the GCC back-end information about how to optimize the code that we generate. For example: - We can tell GCC when it is safe to treat function calls as tail calls. (The gcc back-end already has some support for doing tail calls. But its check to determine when it is safe to do them is much too conservative for Mercury. I've been working on extending the gcc back-end infrastructure so that front ends can tell the gcc back-end when it is safe.) - We can use `__builtin_{set,long}jmp' rather than ordinary `{set,long}jmp'. (We can also do this for the C back-end, as it happens, since those are supported in GNU C too, but I wouldn't have found out about it if not for doing this back-end.) Or we can use gcc's exception handling; the gcc developers have told me that using exception handling may be more efficient on some platforms. - We can mark GC_malloc as an allocation function, so that GCC knows that stuff allocated with it won't alias other pointers. - In general we could give GCC more information about aliasing. I haven't investigated this much yet, but I think the GCC back-end has support for keeping track of alias sets and recording which set each pointer points to and which sets may be subsets of which other sets. Another advantage is that it provides a demonstration of how to compile logic languages or functional languages using the GNU C back-end. This may be useful to researchers or open-source developers who are working on other languages. It is also good public relations, because it removes one more barrier towards acceptance of Mercury. Some people want a language implementation that has a "native code compiler", and don't want one that compiles via C. These people may be more willing to consider Mercury now. gcc/mercury: New directory. This contains the C side of the Mercury <-> GCC interface. gcc/mercury/Make-lang.in: gcc/mercury/config-lang.in: gcc/mercury/lang-specs.h: Makefile/configure/specs fragments (respectively) that are required by GCC. gcc/mercury/lang-options.h: Documents the Mercury-specific gcc options, in particular the `--mmc-flag=' option. gcc/mercury/mercury-gcc.c: gcc/mercury/mercury-gcc.h: This is the "meat" on the C side of the Mercury <-> GCC interface. These files provide the C code that GCC requires of each language front-end. They also define some routines for building parts of the GCC `tree' data structure that are used by the Mercury compiler. gcc/mercury/Makefile: A Makefile which just runs `make mercury' in the parent directory. Just for convenience. gcc/mercury/README: gcc/mercury/ChangeLog: Some (very basic) documentation. gcc/mercury/test.m: A sample Mercury module, to serve as a simple test case. gcc/mercury/testmercury.c: C driver program for the test Mercury module. mercury/compiler/gcc.m: New file. This is an interface to the tree data structure defined in gcc/tree.h, and to functions for manipulating that data structure which are defined in gcc/mercury/mercury-gcc.c and in other parts of the GCC back-end. It's almost entirely composed of simple pragma c_code routines that each just call a single C function. mercury/compiler/mlds_to_gcc.m: New file. This converts the MLDS into the gcc tree representation whose interface is in gcc.m, using the routines defined in gcc.m. This is the "meat" on the Mercury side of the Mercury <=> GCC interface. mercury/compiler/globals.m: Define new target `asm', for compiling directly to assembler (without any intermediate files), via the gcc back-end. mercury/compiler/handle_options.m: `--target asm' implies `--high-level-code'. mercury/compiler/mercury_compile.m: Handle `--target asm' by invoking mlds_to_gcc.m. mercury/main.c: New file, containing main() that calls mercury_main(). mercury/compiler/Mmakefile: Add C2INITFLAGS=--library, so that we can link `libmercury_compile.a' as a library without main(). For the mercury_compile executable, get main by linking in ../main.o. Add `libmmc' target, for building libmercury_compile.a and mercury_compile_init.a. Add the appropriate `-D' and `-I' options to CFLAGS-gcc so that we can compile gcc.m. mercury/runtime/mercury.c: Define out-of-line copies of MR_box_float() and MR_unbox_float(), so that the new `--target asm' back-end can generate calls to them. mercury/runtime/mercury.h: mercury/runtime/mercury_heap.h: Add comments warning about code duplication between the inline and out-of-line versions of various functions. mercury/Makefile: mercury/Mmakefile: Add `libmmc' target, for use by gcc/mercury/Make-lang.in. mercury/runtime/mercury_std.h: When IN_GCC is defined, use safe_ctype.h rather than ctype.h, since the latter conflicts with the GCC headers. Comment out the definition of the `reg' macro, since that too conflicts with the GCC headers. mercury/runtime/mercury_dlist.c: mercury/runtime/mercury_hash_table.c: mercury/runtime/mercury_stacks.h: Delete unnecessary uses of the `reg' macro.	2001-01-10 10:57:25 +00:00
Levi Cameron	c0b9886c47	Deleted unnecessary local variables from the MR_mktempframe macros. ... Estimated hours taken: 0.1 runtime/mercury_stacks.h Deleted unnecessary local variables from the MR_mktempframe macros.	2000-12-13 06:06:16 +00:00
Fergus Henderson	1e9195b4f3	Add some Mmake rules to the runtime and some code to tools/bootcheck ... Estimated hours taken: 16 Add some Mmake rules to the runtime and some code to tools/bootcheck so that we automatically check that the namespace remains clean. Also add some `MR_' prefixes that Zoltan missed in his earlier change. tools/bootcheck: Add an option, which is enabled by default, to build the check_namespace target in the runtime. runtime/RESERVED_MACRO_NAMES: New file. Contains a list of the macros names that don't start with `MR_' or the like. runtime/Mmakefile: Change the rule for `check_headers' so that it checks for macros that don't occur in the RESERVED_MACRO_NAMES files, as well as not starting with `MR_' prefixes, and reports errors for such macros. Also add a rule for check_objs that checks whether the object files define any global symbols that don't have the right prefixes, and a rule `check_namespace' that does both of the above. runtime/mercury_bootstrap.h: #include "mercury_types.h" and "mercury_float.h", to ensure that this header file is self-contained. Also make sure that all the old names are disabled if you compile with `-DMR_NO_BACKWARDS_COMPAT'. runtime/mercury_context.c: runtime/mercury_thread.h: runtime/mercury_thread.c: Use `bool' rather than `MR_Bool' for the argument to MR_check_pending_contexts() and the return type of MR_init_thread(), since these are C bools, not Mercury bools, and there's no requirement that they have the same size as MR_Integer. runtime/mercury_type_info.h: runtime/mercury_deep_copy_body.h: runtime/mercury_tabling.c: library/std_util.m: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_internal.c: tests/hard_coded/existential_types_test.m: Add MR_ prefixes to UNIV_OFFSET_FOR_TYPEINFO and UNIV_OFFSET_FOR_VALUE. trace/mercury_trace_external.c: trace/mercury_trace_internal.c: trace/mercury_trace_tables.c: Add MR_ prefixes to do_init_modules(). runtime/mercury_tabling.h: runtime/mercury_tabling.c: runtime/mercury_overflow.h: runtime/mercury_debug.h: Add MR_ prefixes to table_*. runtime/mercury_overflow.h: runtime/mercury_debug.h: Add MR_ prefixes to IF(). runtime/mercury_context.h: Add MR_ prefixes to IF_MR_THREAD_SAFE(). runtime/mercury_engine.h: Add MR_ prefixes to IF_NOT_CONSERVATIVE_GC(). runtime/mercury_engine.h: runtime/mercury_engine.c: library/exception.m: extras/aditi/aditi.m: Add MR_ prefixs to do_fail, do_redo, do_not_reached, etc. compiler/trace.m: compiler/fact_table.m: compiler/llds_out.m: Add MR_ prefixes to the generated code.	2000-12-04 18:35:22 +00:00
Zoltan Somogyi	210a596aaf	Make even things used only in grade none use MR_ prefixes. ... Estimated hours taken: 2 Make even things used only in grade none use MR_ prefixes. runtime/mercury_memory.c: Delete some obsolete global variables that were replaced by fields of the engine structure ages ago. Their declaration gets a syntax error in grade none. runtime/mercury_engine.h: Remove some confusing macros for referring to these fields. runtime/mercury_*.[ch] Add MR_ prefixes as necessary. Get rid of references to the confusing macros. library/exception.m: Add MR_ prefixes as necessary. Get rid of references to the confusing macros. library/std_util.m: Add MR_ prefixes as necessary.	2000-11-24 06:03:38 +00:00
Zoltan Somogyi	090552c993	Make everything in the runtime use MR_ prefixes, and make the compiler ... Estimated hours taken: 10 Make everything in the runtime use MR_ prefixes, and make the compiler bootstrap with -DMR_NO_BACKWARDS_COMPAT. runtime/mercury_*.[ch] Add MR_ prefixes to all functions, global variables and almost all macros that could pollute the namespace. The (intentional) exceptions are 1. some function, variable, type and label names that already start with MR_, mercury_, Mercury or _entry; 2. some standard C macros in mercury_std.h; 3. the macros used in autoconfiguration (since they are used in scripts as well as the runtime, the MR_ prefix may not be appropriate for those). In some cases, I deleted things instead of adding prefixes if the "things" were obsolete and not user visible. runtime/mercury_bootstrap.h: Provide MR_-less forms of the macros for bootstrapping and for backward compatibility for user code. runtime/mercury_debug.[ch]: Add a FILE * parameter to a function that needs it. compiler/code_info.m: compiler/export.m: compiler/fact_table.m: compiler/llds.m: compiler/llds_out.m: compiler/pragma_c_gen.m: compiler/trace.m: Add MR_ prefixes to the C code generated by the compiler. library/*.m: Add MR_ prefixes to handwritten code. trace/mercury_trace_*.c: util/mkinit.c: Add MR_ prefixes as necessary. extras/concurrency/semaphore.m: Add MR_ prefixes as necessary.	2000-11-23 02:01:11 +00:00
Tyson Dowd	db64a3588d	Add MR_ prefixes to the types used when generating C code. ... Estimated hours taken: 4 Add MR_ prefixes to the types used when generating C code. This means types such as Word, String, Bool, Float become MR_Word, MR_String, MR_Bool, MR_Float. Also define MR_Box for both the LLDS and MLDS backends so we can use it uniformly. This is very important in environments where String or Bool have already been used as system types (for example, managed C++). And besides, we should do it anyway as part of the grand namespace cleanup. I have fixed all of the uses of the non-prefixed types in the runtime and trace directories. I haven't done it for the library and compiler directories yet (no promises that I will do it in future either). But if you see a non-prefixed type in code from now on, please consider it a bug and fix it. mercury_bootstrap.h contains #defines to map the non-prefixed types into the prefixed ones. Like many of the other namespace cleaning backwards compatibility macros, this can be turned off with MR_NO_BACKWARDS_COMPAT. This shouldn't break any code, but this kind of change affects so many things that of course there could be problems lurking in there somewhere. If you start getting errors from the C compiler after this change is installed, you will want to make sure you at least have the runtime system updated so that you are getting the backwards compatibility definitions in mercury_bootstrap.h. Then if you continue to have problems you can bug me about it. compiler/export.m: compiler/llds_out.m: compiler/mlds_to_c.m: Use MR_Word, MR_Float, MR_Bool, etc when generating C. doc/reference_manual.texi: Update the reference manual to talk about MR_Word, MR_String, MR_Char, etc. runtime/mercury_bootstrap.h: Add bootstrapping typedefs. runtime/*: trace/*: Change Word, Float, Bool, Code, String, etc to MR_Word, MR_Float, MR_Bool, MR_Code, MR_String.	2000-08-03 06:19:31 +00:00
Fergus Henderson	bf8a0ac7c4	Fix an off-by-one error in the definition of MR_EXCEPTION_FRAMEVARS. ... Estimated hours taken: 3.5 runtime/mercury_stacks.h: Fix an off-by-one error in the definition of MR_EXCEPTION_FRAMEVARS.	2000-06-16 21:08:13 +00:00
Zoltan Somogyi	1eb831eb34	A major cleanup of the internals of tabling. ... Estimated hours taken: 40 A major cleanup of the internals of tabling. Tabling builds up two kinds of tables, both conceptually tries. For call tables, there is one layer in the trie for each input argument; for answer tables, there is one layer in the trie for each output argument. However, the way each trie node is implemented depends on the type of the relevant argument. In addition, what is stored at the tips of the call and answer tables also depends on what kind of tabling (e.g. loopcheck, memo, minimal model) is being performed on the current predicate, and (in some cases) on what stage the execution of the current predicate has reached. Previously, all trie nodes were declared with the C type Word **, and were cast to their actual types at the point of use, with the casts mostly being hidden inside macros. This arrangement lacked readability and was highly error prone. I have replaced it with a system in which trie nodes are declared with a C type which is a pointer to a union of all the possible actual types. There are very few casts left in the internals of the tabling system; this change replaces them with casts at the interface (in the predicates of private_builtin.m) and the use of the various fields of the union. library/private_builtin.m: Changes to conform to the changed types in mercury_tabling.h. In some cases, improve the debugging support. Do not table the typeinfos of polymorphic types in the table_lookup_insert_poly predicate; since those typeinfos are also arguments, and since they appear before the polymorphic arguments, they have already been tabled by the time table_lookup_insert_poly is called. library/private_builtin.m: library/io.m: Add an interface to a new function in the runtime to report statistics about the operation of the tabling system. runtime/mercury_tabling.h: Define and document the new types. Add macros for allocating memory for holding one or more structures. Make the existing macros call the versions that check for malloc returning NULL. runtime/mercury_tabling_macros.h: This new file contains macros that used to be part of the file mercury_tabling.h. The macros call the functions defined in mercury_tabling.c, but they also optionally print debugging messages. runtime/Mmakefile: Add mercury_tabling_macros.h to the list of header files. runtime/mercury_tabling.c: Conform to the new system of C types. Recode the hash table routines to achieve code commonality, better debugging and statistics gathering support, much greater readability, and the following three performance benefits: 1. The old code used open addressing to resolve collisions. In many uses of tabling, successive searches specify keys that have neighboring hash values, which frequently leads to very long searches (I have observed searches that searched more than half the slots of the hash table.) The new code uses separate chaining to resolve collisions. 2. The old code called GC_malloc whenever it inserted a new element into the table. The new code amortizes this overhead over a substantial (and configurable) number of insertions. 3. In order to check whether the hash table should be expanded, the old code was executing a float multiplication and a float comparison on every hash table access. The new code executes the float multiplication only when the table size is changed; in the usual case it only executes an integer comparison, which is much cheaper. Recode the routines for tabling typeinfos for higher speed. Instead of storing them in a binary search tree, which requires lots of comparisons, store the address of the type_ctor_info in a hash table and chain its argument typeinfos from that. Add support for expandable tables, which are implemented as arrays indexed by key - start. This is not used yet, but will be used for I/O tabling soon. runtime/mercury_stacks.c: Conform to the new system of C types for tabling. Improve the debugging support. runtime/mercury_wrapper.c: When debugging tabling, set stdout to be line buffered. runtime/mercury_engine.h: runtime/mercury_wrapper.c: Add a new debugging flag, -dH, for debugging the operation of hash tables. In mercury_wrapper.c, sort the code fragments for for processing the arguments of -d. runtime/mercury_trace_base.c: Disable the generation of nuisance debugging messages from Mercury initialization code called before main, which may have been compiled with MR_TABLE_DEBUG enabled. runtime/mercury_conf_param.h: Document MR_TABLE_STATISTICS as well as MR_TABLE_DEBUG. trace/mercury_trace_internal.c: Disable the generation of nuisance debugging messages from Mercury code called by the debugger that may have been compiled with MR_TABLE_DEBUG enabled, by turning off MR_tabledebug when MR_trace is entered. We then turn MR_tabledebug back on (even if it wasn't turned on in the first place) when executing debugger commands that require it to be turned on in order to work. tests/tabling/fib.m: Improve the (commented out) debugging support. Start the search for the right problem size closer to its probable end point. tests/tabling/fib_{float,string,list}.{m,exp}: New test cases to test the low-level routines for tabling floats, strings, and user-defined types; they are all modified versions of fib. tests/tabling/expand.{m,exp}: tests/tabling/expand_float.{m,exp}: tests/tabling/expand_poly.{m,exp}: New test cases to test the code for resizing (i.e. expanding) hash tables, and the code for handling polymorphic arguments. tests/tabling/Mmakefile: Enable the new test cases.	2000-01-03 08:53:15 +00:00
Zoltan Somogyi	bca4cb8162	Make the entire Mercury system bootstrap without backwards compatbility. ... Estimated hours taken: 12 Make the entire Mercury system bootstrap without backwards compatbility. compiler/llds_out.m: compiler/pragma_c_gen.m: Add MR_ prefixes on generated code. library/builtin.m: library/exception.m: library/private_builtin.m: library/std_util.m: library/store.m: Add MR_ prefixes. runtime/mercury_deep_copy_body.h: runtime/mercury_heap.h: runtime/mercury_stacks.h: runtime/mercury_string.h: runtime/mercury_tags.h: runtime/mercury_type_info.h: Add MR_ prefixes. runtime/mercury_bootstrap.c; runtime/mercury_engine.c; runtime/mercury_ho_call.c; runtime/mercury_tabling.c; runtime/mercury_trace_base.c; runtime/mercury_type_info.c; runtime/mercury_wrapper.c; Add MR_ prefixes. In some cases, fix indentation; in functions using four-space indentation, convert all tabs to spaces. trace/mercury_trace_browse.m: trace/mercury_trace_declarative.m: trace/mercury_trace_external.m: trace/mercury_trace_help.m: Add MR_ prefixes.	1999-09-27 05:20:58 +00:00
Fergus Henderson	cd206ed3dc	Add support for Mercury exception handling to call_engine(). ... Estimated hours taken: 16 Add support for Mercury exception handling to call_engine(). Currently that support is not yet used, but the idea is to eventually use this to e.g. allow Mercury exceptions to be automatically converted into C++ exceptions when you export a Mercury procedure to C++. runtime/mercury_stacks.h: Add stuff for exception handling, adapted from code in library/exception.m, for use by mercury_engine.c. runtime/mercury_engine.c: Rename call_engine as MR_call_engine(). Add a new parameter `bool catch_exceptions', and change the result type from `void' to `Word *'. If the catch_exceptions is true, then it installs an exception handler to catch Mercury exceptions and returns the Mercury exception thrown, if any. runtime/mercury_engine.h: Add a new field e_exception to the MercuryEngine structure. This thread-local variable is used to hold the Mercury exception object thrown, if any, when call_engine_inner() returns via longjmp(). Update the prototype for call_engine() to match its new MR_call_engine() interface. runtime/mercury_bootstrap.c: Add a definition of call_engine() that calls MR_call_engine(), for bootstrapping. runtime/mercury_wrapper.c: runtime/mercury_thread.c: compiler/export.m: Call MR_call_engine() rather than call_engine(). runtime/mercury_wrapper.c: Ensure that we do not clobber the value of MR_curfr in do_interpreter, since it may be needed for the exception handler frame in MR_call_engine() if do_interpreter were invoked via MR_call_engine(ENTRY(do_interpreter), TRUE). library/exception.m: Simplify the code for the different builtin_catch procedures by using the MR_create_exception_handler() macro defined in mercury_stacks.h (this avoids quite a bit of code duplication in the old code). Modify the code for builtin_throw to allow the exception handler to be C code; in that case, we save the exception object in the e_exception field of the MercuryEngine and then jump to the exception handler using longjmp().	1999-09-16 09:24:40 +00:00
Zoltan Somogyi	566cec5b30	Prefix everything defined in runtime/mercury_{stacks,tags}.h MR_. ... Estimated hours taken: 3 Prefix everything defined in runtime/mercury_{stacks,tags}.h MR_. In the process, get rid of the grade component MR_DEBUG_NONDET_STACK, since this makes the update to mercury_stacks.h simpler and its use is long obsolete. runtime/mercury_tags.h: Put MR_ prefixes in front of everything defined here. runtime/mercury_stacks.h: Put MR_ prefixes in front of everything defined here. Remove support for MR_DEBUG_NONDET_STACK. Replace most of the lost functionality by calling an updated mkframe_msg. Remove the definitions of push() and pop(). Their use conflicts with the idea that everything on the det stack is part of a frame, which the RTTI stuff depends on. runtime/mercury_bootstrap.h: Add backward compatibility macros for the old names in the above two files. Remove some old entries in this file which are no longer needed. runtime/mercury_wrapper.c: Remove the only uses of push() and pop(). Put MR_ in front of some things that need them. runtime/mercury_engine.c: Put MR_ in front of some things that need them. runtime/mercury_misc.[ch]: Make mkframe_msg get the name of the procedure that owns the stack frame from an explicitly passed argument, rather than the prednm slot (which no longer exists). This actually improves low-level debugging support without MR_DEBUG_NONDET_STACK. Remove unnecessary return statements. runtime/mercury_debug.h: Pass on the new arg of mkframe_msg. Fix long lines. runtime/mercury_conf_param.h: Remove the documentation of MR_DEBUG_NONDET_STACK. runtime/mercury_grade.h: Remove the grade component of MR_DEBUG_NONDET_STACK. doc/reference_manual.texi: Document the MR_ prefixed versions of list_empty, list_cons etc. library/io.m: library/std_util.m: library/string.m: Add prefixes to some references to the runtime.	1999-04-30 04:25:43 +00:00
Zoltan Somogyi	dc03496d06	Rewrite significant parts of minimal model tabling so that it works ... Estimated hours taken: 130 Rewrite significant parts of minimal model tabling so that it works in a much wider variety of situations, including coups. Also, clean up the tabling implementation to make it more maintainable, and introduce a new grade component, .mm, that enables minimal model tabling. (Minimal model tabling requires distributed fat, and we don't want to incur such costs unless necessary.) compiler/options.m: Add a new option --use-minimal-model, which for now is documented as "not for general use". This option is a grade option, and is required if minimal model tabling is to work. compiler/handle_options.m: When --use-minimal-model is given, do not allow nondet frame hijacks, since minimal model tabling cannot cope with hijacks. Make --use-minimal-model a grade component. compiler/code_info.m: When --use-minimal-model is given, insert calls to MR_commit_{mark,cut} around goals being committed across. This is now necessary, so that we can detect and handle sitations where a goal being committed across starts but does not complete a tabled goal. compiler/table_gen.m: Rename many of the tabling helper predicates, using a naming scheme that separates predicates used for model_non procedures from those used to implement simpler forms of tabling, while bringing out the parallels between these two sets of predicates. When calls to two tabling helper predicates always occur one after the other, merge the two into one. Generate and use more meaningful variable names; having all of the several variables inserted by this transformation named TableVar was quite confusing. library/private_builtin.m: Reorganize this file, to separate out the different sections. The contents of the non-tabling sections were not modified, only moved around. Rename the predicates referred to by table_gen.m. Move most of the type declarations and complex code out of here, into runtime/mercury_tabling.c. This makes it easier to debug them, since (a) creating a new executable is quicker, since you don't have to wait for lots of mercury compiler invocations, and (b) gdb doesn't get confused by #line directives. It also makes it easier to write them, since you don't have to !&(*U&( remember to double all your double quotes and to backslash all your backslashes. runtime/mercury_grade.h: Include a grade component reflecting whether MR_USE_MINIMAL_MODEL is defined. runtime/mercury_conf_param.h: Document MR_USE_MINIMAL_MODEL. runtime/mercury_stacks.[ch]: The changes to tabling require the addition of two new stacks, the generator stack and the cut stack. This module defines the structures of the frames of these stacks and provides the operations on these stacks. The header file also contains some additional macros that return the addresses of fixed nondet stack slots, not their contents, for use by tabling code. runtime/mercury_context.[ch]: runtime/mercury_memory.[ch]: runtime/mercury_wrapper.[ch]: Declare and set up the two new stacks, both in saved contexts and in the active context, if MR_USE_MINIMAL_MODEL is defined. runtime/mercury_regorder.h: Add four new global virtual machine registers to hold pointers to the memory areas of the two new stacks and the current offsets within them. These are defined whether MR_USE_MINIMAL_MODEL is defined or not, since the cost is minimal and the potential bugs we avoid would be hard to track down. runtime/mercury_engine.h: runtime/mercury_wrapper.c: Add support for a new debugging flag, -dS, which prints the contents of the nondet stack at several points during tabling. runtime/mercury_tabling.[ch]: The implementation of the new tabling system. Much of the new code here is stuff moved from library/private_builtin.m, but in a significantly rewritten form. There is also substantial new code, e.g. to handle the extension of saved stack segments, and to manage dependencies between subgoals in general. Improve the documentation considerably. Replace lists stored as Mercury data structures with lists stored as linked structures in the usual C fashion. This allows us to use debuggers such as ddd on these data structures, whose complexity requires this. Ensure that global names start with MR_. runtime/mercury_init.h: Explicitly include mercury_regs.h at the start. Without this, we get an error, because now mercury_wrappers.h, which mercury_init.h includes, also includes mercury_regs.h, but not before functions have been declared. runtime/Mmakefile: Refer to the new file mercury_stacks.c (mercury_stacks.h already existed, but the module consisted entirely of macros.) Fix a sorting error. scripts/{init,parse,final}_grade_options.sh-subr: scripts/mgnuc.in: Handle the new grade component. tests/tabling/* Add several new test cases that we now pass, most of which we couldn't pass before. Also add some new test cases that we don't pass yet, due to interactions between tabling and negated contexts. trace/mercury_trace_internal.c: If MR_USE_MINIMAL_MODEL is defined, add a new command to print the generator stack. (The new command is deliberately not documented in doc/mdb_doc yet, since (a) it is intended for developers only, and (b) there is no way to test MR_USE_MINIMAL_MODEL in mdb_doc.)	1999-04-20 11:48:56 +00:00
Fergus Henderson	0eff4d00d4	Fix a bug in makepragmaframe() that caused it to allocate ... Estimated hours taken: 0.25 runtime/mercury_stacks.h: Fix a bug in makepragmaframe() that caused it to allocate too much memory: convert the struct size from bytes to words before adding it to MR_maxfr.	1998-12-16 20:38:15 +00:00
Mark Brown	2983a654ed	Add parentheses around a parameter of MR_based_stackvar, to ... Estimated hours taken: 1 runtime/mercury_stacks.h: Add parentheses around a parameter of MR_based_stackvar, to avoid errors when the argument is an expression such as ``slot + 1''.	1998-11-23 06:46:01 +00:00
Fergus Henderson	7a62809cfd	Move some more #defines that were there just for backwards ... Estimated hours taken: 1 runtime/mercury_bootstrap.h: runtime/mercury_stacks.h: Move some more #defines that were there just for backwards compatibility into mercury_bootstrap.h. runtime/mercury_imp.h: runtime/mercury_bootstrap.h: Put the #include of "mercury_bootstrap.h" last rather than first, since the macros defined in mercury_bootstrap.h should not be used in other header files. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_context.h: runtime/mercury_context.c: runtime/mercury_misc.c: runtime/mercury_type_info.c: Use the new macros instead of the old ones that have now been moved to "mercury_bootstrap.h".	1998-11-11 02:14:19 +00:00
Fergus Henderson	779b47f4f2	Various bug fixes and cleanups for the code in the runtime directory. ... Estimated hours taken: 2 Various bug fixes and cleanups for the code in the runtime directory. runtime/mercury_bootstrap.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_type_info.h: Move #defines that are there just for backwards compatibility into mercury_bootstrap.h. runtime/process_getopt: Add MR_ prefixes to the names `_GETOPT_H', `no_arguments', and `required_argument' which are defined by mercury_getopt.h, to make mercury_getopt.h macro-namespace-clean. runtime/mercury_getopt.h: Apply the new version of the process_getopt script. runtime/mercury_imp.h: Make mercury_bootstrap the first header file that is #included, in case some of the macros defined in it are used in declarations in other header files. runtime/mercury_memory.h: Delete duplicate definitions of MAX_REAL_REG, NUM_SPECIAL_REG, and MAX_VIRTUAL_REG -- these are all already defined in mercury_memory_zones.h. runtime/mercury_memory_zones.h: Delete definition of NUM_SPECIAL_REG, since mercury_regorder.h already defines MR_NUM_SPECIAL_REG, which should be used instead of NUM_SPECIAL_REG. The value of NUM_SPECIAL_REG was long obsolete. runtime/mercury_regorder.h: Fix some bugs in the definition of MR_min_sol_hp_rec -- it was using `mr40', which is undefined, instead of `mr(40)'. Also add some comments. runtime/mercury_regs.h: Fix a bug: use MR_NUM_SPECIAL_REGS instead of NUM_SPECIAL_REGS. Note that this bug fix unfortunately breaks backwards compatibility, at least for procedures with more than 32 arguments, since it affects the mapping from r(N) to the fake_reg array. However, there was no alternative, since the old mapping was broken: for example, the old mapping used the same fake_reg slot for both r(41) and MR_global_hp. runtime/mercury_bootstrap.h: Change MR_GRADE_PART_0 from `redofr' to `v1', and document that that part of the grade is a binary compatibility version number. The reason for changing the grade is to ensure that the change in binary backwards compatibility resulting from the changes to runtime/mercury_regs.h will cause link errors rather than just random behaviour for procedures with >32 arguments. runtime/mercury_agc_debug.c: Use MR_NUM_SPECIAL_REGS instead of NUM_SPECIAL_REGS. Also add some XXX comments, since all of the places where NUM_SPECIAL_REGS was used are broken anyway -- they should be using MAX_FAKE_REG instead of MAX_REAL_REG + NUM_SPECIAL_REG. But I think the current definition is put there for efficiency, even though it's known to be broken for procedures with >32 arguments, so I didn't change the code to use MAX_FAKE_REG.	1998-11-09 14:35:40 +00:00