37 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	2dc982cfe4	Make a representation of the program available to the deep profiler. ... Estimated hours taken: 50 Branches: main Make a representation of the program available to the deep profiler. We do this by letting the user request, via the option "--deep-procrep-file" in MERCURY_OPTIONS, that when the Deep.data file is written, a Deep.procrep file should be written alongside it. The intended use of this information is the discovery of profitable parallelism. When a conjunction contains two expensive calls, e.g. p(...) and q(...) connected by some shared variables, the potential gain from executing them in parallel is limited by how early p produces those variables and how late q consumes them, and knowing this requires access to the code of p and q. Since the debugger and the deep profiler both need access to program representations, put the relevant data structures and the operations on them in mdbcomp. The data structures are significantly expanded, since the deep profiler deals with the whole program, while the debugger was interested only in one procedure at a time. The layout structures have to change as well. In a previous change, I changed proc layout structures to make room for the procedure representation even in non-debugging grades, but this isn't enough, since the procedure representation refers to the module's string table. This diff therefore makes some parts of the module layout structure, including of course the string table, also available in non-debugging grades. configure.in: Check whether the installed compiler can process switches on foreign enums correctly, since this diff depends on that. runtime/mercury_stack_layout.[ch]: runtime/mercury_types.h: Add a new structure, MR_ModuleCommonLayout, that holds the part of the module layout that is common to deep profiling and debugging. runtime/mercury_deep_profiling.[ch]: The old "deep profiling token" enum type was error prone, since at each point in the data file, only a subset was applicable. This diff breaks up the this enum into several enums, each consisting of the choice applicable at a given point. This also allows some of the resulting enums to be used in procrep files. Rename some enums and functions to avoid ambiguities, and in one case to conform to our naming scheme. Make write_out_proc_statics take a second argument. This is a FILE * that (if not NULL) asks write_out_proc_statics to write the representation of the current module to specified stream. These module representations go into the middle part of the program representation file. Add functions to write out the prologue and epilogue of this file. Write out procedure representations if this is requested. Factor out some code that is now used in more than one place. runtime/mercury_deep_profiling_hand.h: Conform to the changes to mercury_deep_profiling.h. runtime/mercury_builtin_types.c: Pass the extra argument in the argument lists of invocations of write_out_proc_statics. runtime/mercury_trace_base.[ch]: Conform to the name change from proc_rep to proc_defn_rep in mdbcomp. runtime/mercury_grade.h: Due to the change to layout structures, increment the binary compatibility version numbers for both debug and deep profiling grades. runtime/mercury_wrapper.[ch]: Provide two new MERCURY_OPTION options. The first --deep-procrep-file, allows the user to ask for the program representation to be generated. The second, --deep-random-write, allows tools/bootcheck to request that only a fraction of all program invocations should generate any deep profiling output. The first option will be documented once it is tested much more fully. The second option is deliberately not documented. Update the type of the variable that holds the address of the (mkinit-generated) write_out_proc_statics function to accept the second argument. util/mkinit.c: Pass the extra argument in the argument list of write_out_proc_statics. mdbcomp/program_representation.m: Extend the existing data structures for representing a procedure body to represent a procedure (complete with name), a module and a program. The name is implemented as string_proc_label, a form of proc_label that can be written out to files. This replaces the old proc_id type the deep profiler. Extend the representation of switches to record the identity of the variable being switched on, and the cons_ids of the arms. Without the former, we cannot be sure when a variable is first used, and the latter is needed for meaningful prettyprinting of procedure bodies. Add code for reading in files of bytecodes, and for making sense of the bytecodes themselves. (It is this code that uses foreign enums.) mdbcomp/prim_data.m: Note the relationship of proc_label with string_proc_label. mdbcomp/rtti_access.m: Add the access operations needed to find module string tables with the new organization of layout structures. Provide operations on bytecodes and string tables generally. trace/mercury_trace_cmd_browsing.c: Conform to the change to mdbcomp/program_representation.m. compiler/layout.m: Add support for a MR_ModuleCommonLayout. Rename some function symbols to avoid ambiguities. compiler/layout_out.m: Handle the new structure. compiler/stack_layout.m: Generate the new structure and the procedure representation bytecode in deep profiling grades. compiler/llds_out.m: Generate the code required to write out the prologue and epilogue of program representation files. Pass the extra argument in the argument lists of invocations of write_out_proc_statics that tells those invocations to write out the module representations between the prologue and the epilogue. compiler/prog_rep.m: When generating bytecodes, include the new information for switches. compiler/continuation_info.m: Replace a bool with a more expressive type. compiler/proc_rep.m: Conform to the change to continuation_info.m. compiler/opt_debug.m: Conform to the change to layout.m. deep_profiler/mdprof_procrep.m: A new test program to test the reading of program representations. deep_profiler/DEEP_FLAGS.in: deep_profiler/Mmakefile: Copy the contents of the mdbcomp module to this directory on demand, instead of linking to it. This is necessary now that the deep profiler depends directly on mdbcomp even if it is compiled in a non-debugging grade. The arrangements for doing this were copied from the slice directory, which has long done the same. Avoid a duplicate include of Mmake.deep.params. Add the new test program to the list of programs in this directory. Mmakefile: Go through deep_profiler/Mmakefile when deciding whether to do "mmake depend" in the deep_profiler directory. The old actions won't work correctly now that we need to copy some files from mdbcomp before we can run "mmake depend". deep_profiler/profile.m: Remove the code that was moved (in cleaned-up form) to mdbcomp. deep_profiler/dump.m: deep_profiler/profile.m: Conform to the changes above. browser/declarative_execution.m: browser/declarative_tree.m: Conform to the changes in mdbcomp. doc/user_guide.texi: Add commented out documentation of the two new options. slice/Mmakefile: Fix formatting, and a bug. library/exception.m: library/par_builtin.m: library/thread.m: library/thread.semaphore.m: Update all the handwritten modules to pass the extra argument now required by write_out_proc_statics. tests/debugger/declarative/dependency.exp: Conform to the change from proc_rep to proc_defn_rep. tools/bootcheck: Write out deep profiling data only from every 25th invocation, since otherwise the time for a bootcheck takes six times as long in deep profiling grades than in asm_fast.gc. However, do test the ability to write out program representations. Use the mkinit from the workspace, not the installed one. Don't disable line wrapping.	2007-09-12 06:21:20 +00:00
Zoltan Somogyi	0d6c3c9fdf	Satisfy a request by Peter Ross: give mdb users the ability to specify ... Estimated hours taken: 8 Branches: main Satisfy a request by Peter Ross: give mdb users the ability to specify exactly which events inside a procedure they want to put breakpoints on. Amongst other things, this can make checking postconditions easier: you can now put a conditional breakpoint on only the exit event. runtime/mercury_stack_layout.h: Add to the exec trace part of proc layouts fields describing an array of the label layouts describing the events of the procedure. This is the most direct way to implement the new functionality. (In theory, we could search the data structures that map file names and line numbers to label layouts, but that would be complex, inefficient, and *error prone*.) To make room for the new fields, and to prepare for making the procedure body available to the deep profiler as well (which could use it to map execution frequencies of calls back to their location in the procedure body, and thus to things like the frequencies with which various switch arms are selected), move the procedure body of the execution-trace-specific part of the proc layout, and to where the deep profiler could in the future also get at it. runtime/mercury_goto.h: Add macros for declaring more than one label layout structure at a time. compiler/layout.m: Implement the changes in mercury_stack_layout.h in the compiler's data structures as well. compiler/stack_layout.m: Conform to the changes in mercury_stack_layout.h. Turn some tuples into named types. compiler/layout_out.m: Conform to the changes in mercury_stack_layout.h. Add a mechanism to declare the label layouts in the new array before referring to them, by generalizing some existing code. Make this code require that the label layouts we refer to via the macros in mercury_goto.h match the declarations generated by those macros, i.e. that they have information about variables (if debugging is enabled, they will). compiler/opt_debug.m: Conform to the change to layout.m. compiler/prog_rep.m: Make a predicate name more expressive. trace/mercury_trace_cmd_breakpoint.c: Implement the new way of using the "break" command, which is to add a port name after the procedure specification. Register procedures at the start of the function implementing the "break" command, instead of "on demand", since all alternatives eventually do demand it. Write ambiguity reports wholly to mdb's stdout, instead of partially to stderr and partially to stdout. trace/mercury_trace_spy.c: Print the port and the goal path for breakpoints on specific events. Make the invocation conditions left-aligned, not right-aligned. doc/user_guide.texi: Document the new way of using the "break" command. NEWS: Announce the new capability. tests/queens.{inp,exp,exp2}: Add tests of the new capability. tests/breakpoints.{exp,exp}: tests/lval_desc_array.{exp,exp2}: Expect the new alignment of invocation conditions.	2007-06-12 06:06:35 +00:00
Simon Taylor	5647714667	Make all functions which create strings from characters throw an exception ... Estimated hours taken: 15 Branches: main Make all functions which create strings from characters throw an exception or fail if the list of characters contains a null character. This removes a potential source of security vulnerabilities where one part of the program performs checks against the whole of a string passed in by an attacker (processing the string as a list of characters or using `unsafe_index' to look past the null character), but then passes the string to another part of the program or an operating system call that only sees up to the first null character. Even if Mercury stored the length with the string, allowing the creation of strings containing nulls would be a bad idea because it would be too easy to pass a string to foreign code without checking. For examples see: <http://insecure.org/news/P55-07.txt> <http://www.securiteam.com/securitynews/5WP0B1FKKQ.html> <http://www.securityfocus.com/archive/1/445788> <http://www.securityfocus.com/archive/82/368750> <http://secunia.com/advisories/16420/> NEWS: Document the change. library/string.m: Throw an exception if null characters are found in string.from_char_list and string.from_rev_char_list. Add string.from_char_list_semidet and string.from_rev_char_list_semidet which fail rather throwing an exception. This doesn't match the normal naming convention, but string.from_{,rev_}char_list are widely used, so changing their determinism would be a bit too disruptive. Don't allocate an unnecessary extra word for each string created by from_char_list and from_rev_char_list. Explain that to_upper and to_lower only work on un-accented Latin letters. library/lexer.m: Check for invalid characters when reading Mercury strings and quoted names. Improve error messages by skipping to the end of any string or quoted name containing an error. Previously we just stopped processing at the error leaving an unmatched quote. library/io.m: Make io.read_line_as_string and io.read_file_as_string return an error code if the input file contains a null character. Fix an XXX: '\0\' is not recognised as a character constant, but char.det_from_int can be used to make a null character. library/char.m: Explain the workaround for '\0\' not being accepted as a char constant. Explain that to_upper and to_lower only work on un-accented Latin letters. compiler/layout.m: compiler/layout_out.m: compiler/c_util.m: compiler/stack_layout.m: compiler/llds.m: compiler/mlds.m: compiler/ll_backend.*.m: compiler/ml_backend.*.m: Don't pass around strings containing null characters (the string tables for the debugger). This doesn't cause any problems now, but won't work with the accurate garbage collector. Use lists of strings instead, and add the null characters when writing the strings out. tests/hard_coded/null_char.{m,exp}: Change an existing test case to test that creation of a string containing a null throws an exception. tests/hard_coded/null_char.exp2: Deleted because alternative output is no longer needed. tests/invalid/Mmakefile: tests/invalid/null_char.m: tests/invalid/null_char.err_exp: Test error messages for construction of strings containing null characters by the lexer. tests/invalid/unicode{1,2}.err_exp: Update the expected output after the change to the handling of invalid quoted names and strings.	2007-03-18 23:35:04 +00:00
Zoltan Somogyi	aa25c53cf6	For each attribute of each user event, record the order in which the attribute ... Estimated hours taken: 6 Branches: main For each attribute of each user event, record the order in which the attribute it depends on, indirectly as well as directly, should be synthesized. This information allows each attribute to materialized independently of other attributes, a capability we don't yet need, but may need someday. compiler/prog_event.m: Generate this information. compiler/prog_data.m: Make room for the information generated by prog_event. compiler/layout.m: compiler/layout_out.m: Record this information in the layout structures we generate. compiler/opt_debug.m: Conform to the change to layout.m. runtime/mercury_stack_layout.h: Allow the -1 sentinel at the end of the attribute number vector. trace/mercury_trace_vars.c: Make the var_details mdb command (which is for developers only) to print the newly collected information.	2006-12-22 05:37:57 +00:00
Zoltan Somogyi	544aae2355	Implement synthesized attributes at user events. ... Estimated hours taken: 32 Branches: main Implement synthesized attributes at user events. doc/user_guide.texi: Document synthesized attributes. runtime/mercury_stack_layout.h: Include information about synthesized attributes in layout structures. Move the the information about user events that is not specific to a given event occurrence to a central table of user event specifications in the module layout structure, to reduce the space overhead, and allow a future Ducasse style execution monitor to look up information about each event without having to search all label layout structures (e.g. when compiling a set of user commands about what to do at each event into a state machine). Update the current layout structure version number. Introduce a named type to represent HLDS variable numbers in layout structures. runtime/mercury_types.h: Add typedefs for the new types in mercury_stack_layout.h. compiler/prog_data.m: compiler/prog_event.m: Record the call that synthesizes synthesized attributes in terms of attribute numbers (needed by the layout structures) as well as in terms of attribute names (the user-friendly notation). Record some other information now needed by the layout structures, e.g. the evaluation order of synthesized attributes. (Previously, we computed this order -in reverse- but then threw it away.) Do not separate out non-synthesized attributes, now that we can handle even synthesized ones. Return *all* attributes to call_gen.m. Pass the filename of the event set specification file to the event spec parser, for use in error messages. Generate better error messages for semantic errors in event set specifications. compiler/continuation_info.m: compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Generate the new layout structures, the main changes being the inclusion of synthesized attributes, and generating information about event attribute names, types and maybe synthesis calls for all possible events at once (for the module layout) instead of separately at each user event occurrence. In stack_layout.m, rename a couple of predicates to avoid ambiguities. In layout_out.m, eliminate some repetitions of terms. compiler/call_gen.m: When processing event calls, match the supplied attributes against the list of all attributes, and include information about the synthesized attributes in the generated layout structures. compiler/equiv_type.m: compiler/module_qual.m: Conform to the change in prog_data.m. compiler/opt_debug.m: Conform to the change in layout.m. compiler/hlds_out.m: Generate valid Mercury for event calls. trace/mercury_event_spec.[ch]: Record the name of the file being parsed, for use in syntax error messages when the parser is invoked by the compiler. Add a field for recording the line numbers of attributes, for use in better error messages. trace/mercury_event_parser.y: trace/mercury_event_scanner.l: Record the line numbers of attributes. Modify the grammar for event set specifications to allow C-style comments. trace/mercury_trace_internal.c Pass a dummy filename to mercury_event_spec. (The event set specifications recorded in layout structures should be free of errors, since the compiler generates them and it checked the original version for errors.) trace/mercury_trace_tables.[ch]: Conform to the new design of layout structures, and record the extra information now available. trace/mercury_trace_vars.[ch]: Record the values of attributes in two passes: first the non-synthesized attributes, then the synthesized attributes in the evaluation order recorded in the user event specification. tests/debugger/synth_attr.{m,inp,exp}: tests/debugger/synth_attr_spec: New test case to test the debugger's handling of synthesized attributes. tests/debugger/Mmakefile: tests/debugger/Mercury.options: Enable the new test case. tests/invalid/syntax_error_event.{m,err_exp}: tests/invalid/syntax_error_event_spec: New test case to test the handling of syntax errors in event set specifications. tests/invalid/synth_attr_error.{m,err_exp}: tests/invalid/synth_attr_error_spec: New test case to test the handling of semantic errors in event set specifications. tests/invalid/Mmakefile: Enable the new test cases.	2006-12-14 04:36:04 +00:00
Zoltan Somogyi	45fd0daf5a	Implement some of Mark's wish list for making user events more useful. ... Estimated hours taken: 20 Branches: main Implement some of Mark's wish list for making user events more useful. 1. When executing "print *" in mdb, we used to print both the values of all attributes and the values of all live variables. Since some attributes' values were given directly by live variables, this lead to some things being printed twice. This diff eliminates this duplication. 2. At user events, we now print the name of the event. Whether we print the other stuff we also print at events (the predicate containing the event, and its source location) is now controlled by a new mdb command, "user_event_context". 3. We would like different solvers to be compilable independently of one another. This means that neither solver's event set should depend on the existence of the events needed by the other solvers. This diff therefore eliminates the requirement that all modules of the program be compiled with the same event set specification. Instead, a program may contain modules that were compiled with different event sets. Each event set is named; the new requirement is that different named event sets may coexist in the program (each being used to compile some modules), but two event sets with the same name must be identical in all other respects as well (we need this requirement to prevent inconsistencies arising between different versions of the same event set). 4. We now generate user events even from modules compiled with --trace shallow. The problem here is that user events can occur in procedures that do not get caller events and whose ancestors may not get caller events either. Yet these procedures must still pass on debugger information such as call sequence numbers and the call depth to the predicate with the user event. This diff therefore decouples the generation of code for this basic debugger infrastructure information from the generation of call events by inventing two new trace levels, settable by the compiler only (i.e. not from the command line). The trace level "basic_user" is for procedures containing a user event whose trace level (in a shallow traced module) would otherwise be "none". The trace level "basic" is for procedures not containing a user event but which nevertheless may need to transmit information (e.g. depth) to a user event. For the foreseeable future, this means that shallow traced modules containing user events will have some debugging overhead compiled into *all* their procedures. runtime/mercury_stack_layout.h: Add a new field to MR_UserEvent structures, giving the HLDS number of the variable representing each attribute. Add a new field to module layout structures, giving the name of the event set (if any) the module was compiled with. Add the new trace levels to the MR_TraceLevel type. Update the current layout structure version number. runtime/mercury_stack_trace.[ch]: Allow the printing of the containing predicate's name and/or the filename/linenumber context to be turned off when printing contexts. Factor out some of the code involved in this printing. Give a bunch of variables better names. Rename a type to get rid of unnecessary underscores. compiler/prog_data.m: compiler/prog_event.m: Include the event set name in the information we have about the event set. compiler/simplify.m: Mark each procedure and each module that contains user events as containing user events. Use the same technique to mark each procedure that contains parallel conjunctions as containing parallel conjunctions, instead of marking the predicate containing the procedure. (Switch detection may eliminate arbitrary goals, including parallel conjunctions, from switch arms that are unreachable due to initial insts, and in any case we want to handle the procedures of a predicate independently from each other after mode analysis.) Also, change the code handling generic calls to switch on the generic call kind, and factor out some common code. compiler/hlds_module.m: compiler/hlds_pred.m: Provide slots in the proc_info and the module_info for the information gathered by simplify. compiler/trace_params.m: Implement the new trace levels described above. This required changing the signature of some of the predicates of this module. compiler/code_info.m: Record whether the compiler generated any trace events. We need to know this, because if it did, then we must generate a proc layout structure for it. compiler/proc_gen.m: Act on the information recorded by code_info.m. Factor out the code for generating the call event and its layout structure, since the conditions for generating this event have changed. compiler/continuation_info.m: compiler/call_gen.m: For each user event, record the id of the variables corresponding to each argument of a user event. compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Generate the new field (giving the HLDS variable number of each attribute) in user event structures, and the new field (event set name) in module layout structures. Allow the call event's layout structure to be missing. This is needed for user events in shallow traced modules. compiler/options.m: compiler/handle_options.m: compiler/mercury_compiler.m: Rename the option for specifying event sets from --event-spec-file-name to --event-set-file-name, since it specifies only one event set, not all events. compiler/jumpopt.m: Give some predicates better names. compiler/dep_par_conj.m: compiler/deforest.m: compiler/granularity.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/lambda.m: compiler/liveness.m: compiler/modes.m: compiler/opt_debug.m: compiler/optimize.m: compiler/size_proc.m: compiler/stack_alloc.m: compiler/store_alloc.m: compiler/table_gen.m: compiler/trace_gen.m: compiler/typecheck.m: Conform to the changes above. doc/mdb_categories: Mention the new mdb command. doc/user_guide.texi: Update the documentation of user events to account for the changes above. trace/mercury_event_parser.y: trace/mercury_event_scanner.l: Modify the grammar for event set specifications to a name for the event set. trace/mercury_event_spec.[ch]: Instead of recording information about event sets internally in this module, return a representation of each event set read in to the callers, for them to do with as they please. Include the event set name when we print the Mercury term for compiler/prog_event.m. trace/mercury_trace.c: Do not assume that every procedure that contains an event contains a call event (and hence a call event layout structure), since that is not true anymore. trace/mercury_trace_cmd_parameter.[ch]: Implement the new mdb command "user_event_context". trace/mercury_trace_cmd_internal.[ch]: Include "user_event_context" in the list of mdb commands. Print the user event name at user events. Let the current setting of the user_event_context mdb command determine what else to print at such events. Instead of reading in one event set on initialization, read in all event sets that occur in the program. trace/mercury_trace_tables.[ch]: Allow the gathering of information for more than one event set from the modules of the program. trace/mercury_trace_vars.[ch]: For each attribute value of a user event, record what the HLDS variable number of the attribute is. When printing all variables at an event, mark the variable numbers of printed attributes as being printed already, causing the variable with the same number not to be printed. Include the name of the variable (if it has one) in the description of an attribute. Without this, users may wonder why the value of the variable wasn't printed. trace/mercury_trace_cmd_browsing.[ch]: Pass the current setting of the user_event_context mdb command to runtime/mercury_stack_trace.c when printing the context of an event. tests/debugger/user_event_shallow.{m,inp,exp}: New test case to test the new functionality. This test case is the same as the user_event test case, but it is compiled with shallow tracing, and its mdb input exercises the user_event_context mdb command. tests/debugger/user_event_spec: tests/invalid/invalid_event_spec: Update these event set spec files by adding an event set name. tests/debugger/Mmakefile: tests/debugger/Mercury.options: Enable the new test case. tests/debugger/user_event.exp: Update the expected output of the old user event test case, which now prints event names, but doesn't print attribute values twice. tests/debugger/completion.exp: Expect the new "user_event_context" mdb command in the command list. tests/debugger/mdb_command_test.inp: Test the existence of the documentation for the new mdb command. tests/invalid/Mercury.options: Conform to the name change of the --event-spec-file-name option.	2006-12-05 03:51:22 +00:00
Zoltan Somogyi	455e1eea75	The runtime had two different conventions for naming types. ... Estimated hours taken: 2 Branches: main The runtime had two different conventions for naming types. One convention, used mostly in the debugger-related modules, added underscores between capitalized words; example: MR_Label_Layout. The other convention, used in most modules, used capitalized words without underscores (e.g. MR_TypeInfo). This diff standardizes on the second convention. It has no algorithmic changes, only renames of types. runtime/*.[ch]: trace/*.[ch]: compiler/*.m: library/*.m: mdbcomp/*.m: Effect the change described above. The only substantive change is that runtime/mercury_stack_layout.h used to define *two* types for trace levels: MR_TraceLevel and MR_Trace_Level, and this diff standardizes on just one (they had equivalent definitions). runtime/mercury_bootstrap.h: Add a #define from the old name to the new for all the changed type names that the installed compiler can put into .c files. We can delete these #defines some time after this diff has bootstrapped. slice/.mgnuc_opts: Restore the --no-mercury-stdlib-dir option, without which the slice directory won't compile after this change (because it looks for type names in the installed runtime header files, which define the old versions of type names).	2006-11-29 05:18:42 +00:00
Zoltan Somogyi	9ec86d6a6d	The objective of this diff is to switch from a table of solver events built ... Estimated hours taken: 32 Branches: main The objective of this diff is to switch from a table of solver events built into the compiler (and eventually the debugger) into a table of events defined by a file provided by the user to the compiler, which the compiler then records in the executable for use by the debugger. The current design, for speed of implementation, uses temporary files parsed by a bison-generated parser. Since the compiler needs to be able to invoke the parser even if it is compiled in a non-debug grade, the parser is in a new library, the eventspec library, that is always linked into the Mercury compiler and is always linked into any Mercury program with debugging enabled (but is of course linked only once into a Mercury compiler which has debugging enabled). Modify the debugger to give it the ability to print the attributes of user-defined events (for now, only the non-synthesized attributes). Implement a new debugger command, "user", which goes to the next user-defined event. configure.in: Require flex and and bison to be available. doc/user_guide.texi: Document user defined events and the new debugger capabilities. doc/mdb_categories: Include "user" in the list of forward movement commands. Fix some earlier omissions in that list. runtime/mercury_stack_layout.h: Include an event number in the user-defined event structure. Include a string representing an event set specification in module layout structures. runtime/mercury_stack_layout.h: runtime/mercury_trace_base.[ch]: runtime/mercury_types.h Switch from solver events to user events in names. runtime/mercury_trace_term.[ch]: Provide a representation of flat terms, for use in representing the calls that generate synthesized attributes. Ensure that exported field names have an MR_ prefix. browser/cterm.m: Conform to the change to runtime/mercury_trace_term.h. scripts/c2init.in: scripts/ml.in: Include the eventspec library in programs compiled with debugging enabled. compiler/Mmakefile: Include the eventspec library in the compiler. compiler/options.m: Add a new option, --event-spec-file-name, that allows the user to specify the set of user-defined events the program may use. compiler/handle_options.m: Set this optimization from an environment variable (which may be set by the mmc script) if the new option is not explicitly given. compiler/prog_data.m: Define the data structures for the compiler's representation of the event set specification. Move some definitions around to group them more logically. compiler/hlds_module.m: Include the event set specification as a new field in the module_info. compiler/prog_event.m: Add the code for invoking the parser in the eventspec library, and for converting the simple term output by the parser to the compiler own representation, which contains more information (to wit, the types of the function attributes) and which has had a whole bunch of semantic checks done on it (e.g. whether synthesized attributes depend on themselves or on nonexistent attributes). Provide a function to generate a canonicalized version of the event specification file. compiler/module_qual.m: compiler/equiv_type.m: Process event spec specifications as well as items, to module qualify the names of the types of event arguments, and expanding out equivalence types. In equiv_type.m, rename some variables to make clear what kind of info they represent. compiler/mercury_compile.m: Process the event set specification file if one has been selected: read it in, module qualify it, expand its equivalence types, and add to the module_info. compiler/compile_target_code.m: Include the event_spec library when linking debuggable executables. compiler/call_gen.m: compiler/continuation_info.m: compiler/trace_gen.m: compiler/trace_params.m: mdbcomp/prim_data.m: mdbcomp/trace_counts.m: runtime/mercury_goto.h: Generate user-defined events instead of solver events. compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Include a canonicalized version of the event specification file in the module layout if the module has any user-defined events. compiler/code_info.m: compiler/llds_out.m: compiler/modes.m: compiler/modules.m: compiler/opt_debug.m: compiler/typecheck.m: Conform to the changes above. compiler/passes_aux.m: Rename a predicate to avoid an ambiguity. trace/Mmakefile: Add the definition and rules required to build the eventspec library. trace/mercury_event_scanner.l: trace/mercury_event_parser.y: A scanner and a parser for reading in event spec specifications. trace/mercury_event_spec_missing.h: Provide the declarations that should be (but aren't) provided by flex and bison. trace/mercury_event_spec.[ch]: The main module of the eventspec library. Provides functions to read in event set specifications from a file, and to write them out as a Mercury term in the form needed by the compiler. trace/mercury_trace_tables.c: If the module layouts being registered include event set specifications, then check their consistency. Make the specification and the consistency indication available to other modules. trace/mercury_trace_internal.c: During initialization, if the modules contain a consistent set of event set specifications, then read that specification into the debugger. (We don't yet make use of this information.) Add an extra mdb command, "user", which goes forward to the next user-defined event. trace/mercury_trace.[ch]: trace/mercury_trace_cmd_forward.[ch]: Implement the new mdb command. trace/mercury_trace_vars.[ch]: For user-defined events, include the attributes' values among the values that can be printed or browsed. trace/mercury_trace_cmd_browsing.c: trace/mercury_trace_declarative.c: Minor changes. scripts/scripts/prepare_tmp_dir_grade_part: Copy the .y and .l files to the tmp dir we use for installs. tools/bootcheck: Copy the .y and .l files of the trace directory to stage 2. tools/lmc.in: Include the eventspec library when linking debuggable executables. tests/debugger/user_event.{m,inp,exp}: tests/debugger/user_event_spec: New test case to test the new functionality. tests/debugger/Mercury.options: tests/debugger/Mmakefile: Enable the new test case. tests/debugger/completion.exp: Expect the new "user" mdb command in the completion output.	2006-11-24 03:48:30 +00:00
Zoltan Somogyi	9eed887d33	This diff is the second step in implementing trace events. ... Estimated hours taken: 24 Branches: main This diff is the second step in implementing trace events. It modifies label layouts to include room for solver-event-specific information, and modifies the compiler to generate this information. Modifications to the debugger to use this information, user-level documentation and test cases will come later. runtime/mercury_stack_layout.h: Modify label layouts to allow them to hold information about solver events. Modify the macros creating label layouts to include a null pointer as the value of the label layout's solver event field. For each such macro, add a version that puts a pointer to the label's solver event structure in that field. Modify the definition of the MR_Long_Lval type to allow the representation of constants, since without this capability solver events would often need to be preceded by code to put constant values (e.g. solver ids) into lvals. To make it easier to locate all the places where MR_Long_Lvals are used (which need to be updated), change the type MR_Long_Lval from a synonym for an int to a structure containing an int. runtime/mercury_types.h: Add the typedefs now required for mercury_stack_layout.h. runtime/mercury_goto.h: Add a macro needed by mercury_stack_layout.h. runtime/mercury_grade.h: Change the binary compatibility version number for debug grades, due to the change to label layouts. runtime/mercury_layout_util.c: Update the functions interpreting MR_Long_Lvals to conform to the change in mercury_stack_layout.h. runtime/mercury_deep_profiling_hand.h: Fix a bug, possibly the bug preventing us from bootchecking in deep profiling grades: stack slot numbers of ProcStatic structures are supposed to be plain integers, not MR_Long_Lvals. runtime/mercury_stack_trace.c: library/exception.m: trace/mercury_trace.c: Conform the change in MR_Long_Lval. runtime/mercury_trace_base.[ch]: Add a new port: the solver event port. Add a macro and a function for solver events: MR_SOLVER_EVENT and MR_solver_trace. For now, they do the same thing as MR_EVENT and MR_trace, but in future, they can do something else (e.g. generate information for a visualization tool). mdbcomp/prim_data.m: Add a new port: the solver event port. Rename all ports to eliminate clashes with language keywords such as "call". mdbcmp/trace_counts.m: browser/declarative_execution.m: slice/mcov.m: compiler/tupling.m: Conform to the change in port names, and to the addition of the new port. compiler/trace_params.m: Conform to the change in port names, and to the addition of the new port. Rename some function symbols to avoid some ambiguities. trace/mercury_trace_declarative.c: Ignore the solver port when building the annotated trace, since it doesn't fit into it. compiler/prog_event.m: Extend the representation of events to include names for the event attributes. compiler/call_gen.m: Implement event goals. The implementation consists of a call to MR_SOLVER_EVENT with a layout structure whose solver event field points to a solver event structure giving the event goal's arguments. Rename some function symbols to avoid some ambiguities. compiler/trace_gen.m: Add a predicate for generating solver events. Conform to the change in port names. Rename some function symbols to avoid some ambiguities. compiler/code_info.m: When recording trace layout information for a label, take an extra argument describing the label layout's associated solver event, if any. compiler/continuation_info.m: Extend the first representation of label layouts to include room for solver events. compiler/stack_layout.m: Convert the representation of solver events in continuation_info.m's data structure to the data structure required by layout_out.m. Conform to the changes in MR_Long_Lvals. compiler/layout.m: Extend the compiler's internal representation of the contents of label layout structures to accommodate the optional solver event field. compiler/layout_out.m: Generate the extended label layout structures, using the new macros in mercury_stack_layout.h if necessary. Conform to the change in the MR_Long_Lval type. Conform to the change in port names. Rename some function symbols to avoid some ambiguities. compiler/global_data.m: Modify rval_type_as_arg to require only the value of the relevant option, not a package of such options. This is for the new code in stack_layout.m. compiler/var_locn.m: Conform to the change in global_data.m. compiler/llds_out.m: Conform to the change in continuation_info.m. Delete this module's unused definition of rval_type_as_arg. compiler/opt_debug.m: Conform to the change in continuation_info.m.	2006-09-29 06:34:57 +00:00
Zoltan Somogyi	74ce85d476	Provide a mechanism for collecting statistics about tabling operations, ... Estimated hours taken: 60 Branches: main Provide a mechanism for collecting statistics about tabling operations, and provide a much more convenient mechanism for resetting tables. Since it would too complex to do this while preserving the capability of setting --tabling-via-extra-args to no, eliminate that capability and the option. That option was useful only for measurements of the performance boost from setting --tabling-via-extra-args to yes in any case, so users lose no functionality. Previously, the only way to debug the low level details of the tabling mechanism was to build a runtime with a specific C macro (MR_TABLE_DEBUG) and link with that runtime; this was cumbersome. Change that so that every one of the debuggable tabling macros has a bool argument that says whether debugging is enabled or not. The compiler can then set this to MR_TRUE if the new option --table-debug is given, and to MR_FALSE otherwise. If set to MR_FALSE, the C compiler should optimize away the debug code, with zero impact on program size or speed. Since these changes to macros require nontrivial bootstrapping, which we don't want to do unnecessarily, modify the interface of the tabling macros as required to support size limits on tables. This diff also implements the parsing of size limit specifications on tables, but does not implement them yet; that is for a future change. To make the syntax simpler, this diff deletes the free-standing fast_loose_memo pragma. The same functionality is now available with a fast_loose annotation on an ordinary memo pragma. Make a bunch of changes to improve readability and maintainability in the process. These mostly take the form of renaming ambiguous and/or not sufficiently expressive function symbols. runtime/mercury_stack_layout.h: runtime/mercury_tabling.h: Move the description of structure of tables from mercury_stack_layout.h to mercury_tabling.h, since we now need it for statistics even if execution tracing is not enabled. Modify those data structures to have room for the statistics. Don't distinguish "strict", "fast_loose" and "specified" memoing as separate eval methods; treat them as just different kinds of the same eval method: "memo". Remove underscores from the names of some types that the style guide says shouldn't be there. runtime/mercury_tabling_preds.h: runtime/mercury_tabling_macros.h: Modify the approach we use for macros that implement the predicates of library/table_builtin.m. Instead of selecting between debug and nondebug based on whether MR_TABLE_DEBUG is defined or not, add an explicit argument controlling this to each debuggable macro. The advantage of the new arrangement is that it scales. Another argument controls whether we are computing statistics (and if yes, where do we put it), and a third argument controls whether we maintain back links in the tries and hash tables (this last argument is present but is ignored for now). Since the values of the arguments will be known when the .c files containing calls to these macros are compiled, we pay the space and time cost of debugging, statistics gathering and the maintenance of back links if and only we need the revelant functionality. Provide macros for limited backward compatibility with the old set of macros; these allow workspaces created by old compilers to work with the new macros in the runtime. The old macros followed the naming scheme MR_table_*, the new ones are named MR_tbl_*. runtime/mercury_table_int_fix_index_body.h: runtime/mercury_table_int_start_index_body.h: runtime/mercury_table_type_body.h: New files containing parts of the old mercury_tabling.c. Each of these files contains the body of the functions that used to be in mercury_tabling.c. The new mercury_tabling.c #includes each of these files more than once, to provide more than one variant of the old function. These variants differ in aspects such as whether debugging is enabled or statistics is being collected. Each variant therefore incurs only the time costs it needs to. (We pay the space cost of having all these variants all the time of course, but this cost is negligible.) runtime/mercury_tabling_stats_defs.h: runtime/mercury_tabling_stats_nodefs.h: runtime/mercury_tabling_stats_undefs.h: New files that serve as wrappers around the newly #included files, controlling how they handle statistics. runtime/mercury_tabling.c: Delete functions now in the new files, and #include them instead. Delete the data structures that used to contain summary statistics; the new approach keeps statistics in compiler-generated, procedure-specific data structures. runtime/mercury_trace_base.c: Use the new versions of the tabling macros to access the I/O table. runtime/mercury_type_info.h: Update some documentation for the movement of code out of mercury_tabling.c. runtime/mercury_types.h: Provide forward declarations of the identifiers denoting the new types in mercury_tabling.h. runtime/mercury_grade.h: Increment the exec trace version number, since we have changed a part of the exec trace structure. runtime/mercury_bootstrap.h: Fix some temporary issues that arise from some renames above. runtime/mercury_hash_lookup_or_add_body.h: Fix comment. runtime/Mmakefile: Mention the new files and the dependencies that involve them. library/table_builtin.m: Provide a type for representing statistics and a predicate for printing statistics. Use the updated versions of the macros in runtime/mercury_tabling_preds.h. compiler/prog_item.m: Change representation of tabling pragmas to allow room for the new attributes. Allow an item to be marked as being generated by the compiler as a result of a pragma memo attribute. We use this for the reset and statistics predicates. compiler/mercury_to_mercury.m: Write out the new attributes of the tabling pragma. compiler/prog_data.m: compiler/hlds_data.m: Change the cons_id that used to refer to a procedure's call table root to refer to the entirety of the new data structure now containing it. The compiler now needs a way to refer to the other components of this new data structure, since it contains the statistics. As in the runtime, don't distinguish "strict", "fast_loose" and "specified" memoing as separate eval methods; treat them as just different kinds of the same eval method: "memo". Rename some of the uses of the function symbols "c", "java", "il". compiler/hlds_pred.m: Add an extra field in proc_infos for storing any tabling attributes. Change the existing proc_info field that records information about the kinds of arguments of tabled procedures to record the information needed by the debugger too. This was needed to allow us to shift all the RTTI for procedure-specific tables (as opposed to the RTTI for the global I/O table) from mercury_stack_layout.h to mercury_tabling.h without duplicating the data (which would be a maintenance problem). Reformat some comments to make them easier to read. compiler/layout.m: compiler/layout_out.m: Delete the part of the exec trace information that used to record RTTI for tables, since this information is not generated only as part of the debugger data structures anymore. compiler/prog_io_pragma.m: Recognize the updated syntax for tabling pragmas. compiler/add_pragma.m: When processing tabling pragmas for inclusion in the HLDS, create any reset and statistics predicates they ask for. compiler/make_hlds_passes.m: Export a predicate now needed by add_pragma.m. Handle the new attributes on tabling pragmas compiler/globals.m: Change the function symbols of the types describing backends and foreign languages to say what they are. Previously, both types (as well as several others) included the function symbol "c"; now, they are target_c and lang_c respectively. compiler/table_gen.m: Implement the changes described at the top. When passing around varsets and vartypes, pass the arguments in the standard order. compiler/goal_util.m: compiler/hlds_goal.m: When passing around varsets and vartypes, pass the arguments in the standard order. compiler/rtti.m: Provide types for representing the runtime's data structures for tabling (which are now significantly more complex than a single word) and predicates for manipulating them, for use by both the ml and ll backends. compiler/llds.m: Replace the comp_gen_c_var type with the tabling_info_struct type, which contains the information needed to create the per-procedure tabling data structures. Replace references to call tables with references to the various components of the new tabling data structures. compiler/llds_out.m: Add code to write out tabling_info_structs. Delete the code required for the old, hacky way of resetting tables. Reorder some code more logically. compiler/proc_gen.m: Generate tabling_info_structs. compiler/stack_layout.m: Don't generate the information now generated in proc_gen.m. compiler/mlds.m: Give mlds_proc_labels their own function symbols, instead of using a pair. Rename some other function symbols to avoid ambiguity and add expressiveness. Provide for the representation of references to the various components of the new tabling data structures, and for the representation of their types. compiler/ml_code_gen.m: When generating code for a tabled procedure, generate also the data structures required for its table. compiler/rtti_to_mlds.m: compiler/ml_util.m: Move some predicates from rtti_to_mlds.m to ml_util.m, since we now also want to call them from ml_code_gen.m. compiler/name_mangle.m: Add some utility predicates. compiler/options.m: Delete the old --allow-table-reset option. Add the new --table-debug option. Comment out an implementor-only option. compiler/add_pred.m: compiler/add_solver.m: compiler/add_trail_ops.m: compiler/add_type.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/compile_target_code.m: compiler/complexity.m: compiler/dependency_graph.m: compiler/det_report.m: compiler/export.m: compiler/fact_table.m: compiler/foreign.m: compiler/global_data.m: compiler/globals.m: compiler/handle_options.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/make.dependencies.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make.util.m: compiler/make_hlds_passes.m: compiler/mercury_compile.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_elim_nested.m: compiler/ml_optimize.m: compiler/ml_switch_gen.m: compiler/ml_tailcall.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_ilasm.m: compiler/mlds_to_java.m: compiler/mlds_to_managed.m: compiler/modes.m: compiler/module_qual.m: compiler/modules.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/polymorphism.m: compiler/pragma_c_gen.m: compiler/proc_label.m: compiler/prog_data.m: compiler/prog_foreign.m: compiler/prog_item.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/prog_rep.m: compiler/prog_util.m: compiler/recompilation.version.m: compiler/size_prof.m: compiler/special_pred.m: compiler/switch_util.m: compiler/transform_llds.m: compiler/tupling.m: compiler/type_ctor_info.m: compiler/unify_gen.m: Conform to the changes above, and/or improve some comments. mdbcomp/prim_data.m: Make the names of the function symbols of the proc_label type more expressive and less ambiguous. mdbcomp/prim_data.m: mdbcomp/mdbcomp.m: mdbcomp/program_representation.m: mdbcomp/rtti_access.m: mdbcomp/slice_and_dice.m: mdbcomp/trace_counts.m: Use . instead of __ as module qualifier. Conform to the change to prim_data.m. browser/declarative_execution.m: browser/declarative_oracle.m: browser/declarative_tree.m: Conform the change to mdbcomp/prim_data.m. tests/debugger/Mercury.options: Don't specify --allow-table-reset for fib.m, since that option doesn't exist anymore. tests/debugger/fib.m: Use the new mechanism for resetting the table. tests/debugger/print_table.m: Use the new syntax for pragma memo attributes. tests/invalid/specified.{m,err_exp}: Use to the new syntax and reset method for pragma memo attributes. Test the handling of errors in the new attribute syntax. tests/tabling/Mercury.options: Don't specify --allow-table-reset for specified.m, since that option doesn't exist anymore. tests/tabling/specified.m: Use the new syntax for pragma memo attributes, and use the new mechanism for resetting tables. We could also use this test case for testing the printing of statistics, but the format of that output is still not final. tests/tabling/fast_loose.m: Use the new syntax for pragma memo attributes, and use the new mechanism for resetting tables. trace/mercury_trace.c: trace/mercury_trace_cmd_developer.c: Conform to the changes in the RTTI data structures regarding tabling. Remove underscores from the names of some types that the style guide says shouldn't be there. library/robdd.m: Comment out the tabling pragma until this change is bootstrapped. Without this, the conflict between the old calls to macros generated by the existing compiler and the new definition of those macros in the runtime would cause errors from the C compiler.	2006-06-08 08:20:17 +00:00
Zoltan Somogyi	afbec6110a	This diff simplifies the way we handle compiler-generate data in LLDS grades. ... Estimated hours taken: 2 Branches: main This diff simplifies the way we handle compiler-generate data in LLDS grades. We used to wrap several kinds of data structures up in different function symbols so they could be treated as values of a single type, comp_gen_c_data, but then we divided them up into the original caregories again when creating the output .c file. We now instead keep the various kinds of static data separate all the way through. compiler/llds.m: Delete the comp_gen_c_data type. Replace the single list of comp_gen_c_data items in the representation of C files with four lists, one for each kind of static data. compiler/llds_out.m: Make the simplifications made possible by the change to llds.m. Output references to MR_COMMON and MR_TAG_COMMON instead of MR_XCOMMON and MR_TAG_XCOMMON, since the change to make these equivalent should have been installed on all our machines by now. compiler/code_info.m: compiler/global_data.m: compiler/stack_layout.m: Modify data structures to contain data of specific types instead comp_gen_c_datas, and modify the code accordingly. This mostly means avoiding now redundant operations to wrap data structures with comp_gen_c_data's function symbols. compiler/mercury_compile.m: Build c_file structures with four lists of distinct types instead of appending them all to get a single giant list of comp_gen_c_datas. compiler/transform_llds.m: Conform to the change to llds.m. compiler/layout.m: compiler/layout_out.m: Minor style improvements.	2006-05-08 03:36:02 +00:00
Julien Fischer	459847a064	Move the univ, maybe, pair and unit types from std_util into their own ... Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.	2006-03-29 08:09:58 +00:00
Zoltan Somogyi	3ebda6545f	Move the stuff currently in hlds_pred.m that deals with clauses into a new ... Estimated hours taken: 1.5 Branches: main Move the stuff currently in hlds_pred.m that deals with clauses into a new module, hlds_clauses.m. Move the stuff currently in hlds_pred.m that deals with RTTI into a new module, hlds_rtti.m. Move the stuff currently in hlds_module.m that deals with predicate tables into a new module, pred_table.m. These changes make hlds_pred.m and hlds_module.m much more cohesive, but there are no changes in algorithms. compiler/hlds_clauses.m: compiler/hlds_rtti.m: compiler/pred_table.m: New modules as described above. In some cases, fix mixleading or ambiguous predicate names in the process, and convert a few predicates to functions. compiler/hlds_pred.m: compiler/hlds_module.m: Delete the stuff moved to other modules. compiler/*.m: In modules that need the functionality moved a new module, import the new module. It is rare for all the new modules to be needed, and many modules don't need any of the new modules at all. (For example, of the 200+ modules that import hlds_module.m, only about 40 need pred_table.m.) Conform to the few minor changes to e.g. predicate names. compiler/notes/compiler_design.html: Document the new modules.	2006-03-24 03:04:20 +00:00
Zoltan Somogyi	be5b71861b	Convert almost all the compiler modules to use . instead of __ as ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all the compiler modules to use . instead of __ as the module qualifier. In some cases, change the names of predicates and types to make them meaningful without the module qualifier. In particular, most of the types that used to be referred to with an "mlds__" prefix have been changed to have a "mlds_" prefix instead of changing the prefix to "mlds.". There are no algorithmic changes.	2006-03-17 01:40:46 +00:00
Julien Fischer	5f589e98fb	Various cleanups for the modules in the compiler directory. ... Estimated hours taken: 4 Branches: main Various cleanups for the modules in the compiler directory. The are no changes to algorithms except the replacement of some if-then-elses that would naturally be switches with switches and the replacement of most of the calls to error/1. compiler/*.m: Convert calls to error/1 to calls to unexpected/2 or sorry/2 as appropriate throughout most or the compiler. Fix inaccurate assertion failure messages, e.g. identifying the assertion failure as taking place in the wrong module. Add :- end_module declarations. Fix formatting problems and bring the positioning of comments into line with our current coding standards. Fix some overlong lines. Convert some more modules to 4-space indentation. Fix some spots where previous conversions to 4-space indentation have stuffed the formatting of the code up. Fix a bunch of typos in comments. Use state variables in more places; use library predicates from the sv* modules where appropriate. Delete unnecessary and duplicate module imports. Misc. other small cleanups.	2005-11-17 15:57:34 +00:00
Zoltan Somogyi	f9fe8dcf61	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 8 Branches: main Improve the error messages generated for determinism errors involving committed choice contexts. Previously, we printed a message to the effect that e.g. a cc pred is called in context that requires all solutions, but we didn't say *why* the context requires all solutions. We now keep track of all the goals to the right that could fail, since it is these goals that may reject the first solution of a committed choice goal. The motivation for this diff was the fact that I found that locating the failing goal can be very difficult if the conjunction to the right is a couple of hundred lines long. This would have been a nontrivial problem, since (a) unifications involving values of user-defined types are committed choice goals, and (b) we can expect uses of user-defined types to increase. compiler/det_analysis.m: Keep track of goals to the right of the current goal that could fail, and include them in the error representation if required. compiler/det_report.m: Include the list of failing goals to the right in the representations of determinism errors involving committed committed choice goals. Convert the last part of this module that wasn't using error_util to use error_util. Make most parts of this module just construct error message specifications; print those specifications (using error_util) in only a few places. compiler/hlds_out.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: compiler/compiler_util.m: Error_util is still changing reasonably often, and yet it is included in lots of modules, most of which need only a few simple non-parse-tree-related predicates from it (e.g. unexpected). Move those predicates to a new module, compiler_util.m. This also eliminates some undesirable dependencies from libs to parse_tree. compiler/libs.m: Include compiler_util.m. compiler/notes/compiler_design.html: Document compiler_util.m, and fix the documentation of some other modules. compiler/*.m: Import compiler_util instead of or in addition to error_util. To make this easier, consistently use . instead of __ for module qualifying module names. tests/invalid/det_errors_cc.{m,err_exp}: Add this new test case to test the error messages for cc contexts. tests/invalid/det_errors_deet.{m,err_exp}: Add this new test case to test the error messages for unifications inside function symbols. tests/invalid/Mmakefile: Add the new test cases. tests/invalid/det_errors.err_exp: tests/invalid/magicbox.err_exp: Change the expected output to conform to the change in det_report.m, which is now more consistent.	2005-10-28 02:11:03 +00:00
Zoltan Somogyi	905e4a114f	Convert a bunch of modules to four-space indentation. ... Estimated hours taken: 4 Branches: main compiler/*.m: Convert a bunch of modules to four-space indentation. In the process, fix departures from our coding standards. In some cases, do minor other cleanups such as changing argument orders to be friendly to state variables. There are no algorithmic changes.	2005-10-12 23:51:38 +00:00
Ian MacLarty	f362356b17	Make the user friendly names of predicates introduced by lambda expressions ... Estimated hours taken: 4 Branches: main Make the user friendly names of predicates introduced by lambda expressions (more) unique. This is necessary so they can be distinguished from each other in trace count files. If two or more lambda expression appear in the same context, then include their sequence number in that context in the user friendly predicate name. compiler/hlds_module.m: Instead of keeping a counter of how many lambdas appear in a module, keep a seperate counter for each context (filename/lineno). This way we only need to include the sequence number in the predicate name if there are two or more lambdas in the same context. compiler/hlds_pred.m: Add a new field to the `lambda' functor which records the count of the lambda expressin in its context. compiler/hlds_out.m: Unify with lambda/3 instead of lambda/2. compiler/lambda.m: Use the sequence number of the lambda expression in its context when creating the predicate origin. compiler/layout.m: Store the origin of a closure predicate in the layout data of the closure, so that it's user friendly name can be included in the generated C code. compiler/layout_out.m: When generating a user friendly name for lambda expression predicates, include the sequence number of the lambda expression if the sequence number is greater than one. compiler/stack_layout.m: Pass the closure origin to the closure layout construction predicate. compiler/unify_gen.m: Pass the closure origin when constructing the closure layout. tests/debugger/Mmakefile: tests/debugger/lambdatest.exp: tests/debugger/lambdatest.inp: tests/debugger/lambdatest.m: Test that the predicate names for lambda expressions are unique, even if they appear in the same call. tests/debugger/higher_order.exp: tests/debugger/lambda_expr.exp: tests/debugger/declarative/find_origin.exp: tests/debugger/declarative/find_origin.exp2: tests/debugger/declarative/higher_order.exp: tests/debugger/declarative/higher_order.exp2: tests/debugger/declarative/ho2.exp2: tests/debugger/declarative/trust.exp: tests/hard_coded/deconstruct_arg.exp: Expect the new (more) unique predicate names.	2005-05-26 00:17:06 +00:00
Zoltan Somogyi	309910d736	Change the mechanism we use to transmit a representation of procedure bodies ... Estimated hours taken: 16 Branches: main Change the mechanism we use to transmit a representation of procedure bodies from the compiler to the declarative debugger from Mercury terms to a bytecode. This achieves two objectives. First, the code for Mercury terms worked only as long as the compiler used the same data representation as the program being compiled; it generated incorrect term representations when e.g. the compiler generating code in reserve tag grades. Second, the new representation is significantly smaller. The total size of the .c files in the compiler directory in grade asm_fast.gc.decldebug.tr is now only 213 Mb compared with 313 Mb previously (a reduction of almost one third). The executable file size of a compiler compiled in asm_fast.gc.decldebug.tr is now only 59 Mb, compare with 64 Mb previously (a reduction of almost 8%, and there is room for further reductions). The overhead of the decldebug grade when compared with a plain debug grade now only about 25%, compared to about 36% before. The downside is that the procedure body representation must now be constructed by the declarative debugger from the bytecode instead of being available directly. We minimize this effect by using a cache to ensure that each procedure's body representation is constructed at most once. browser/declarative_execution.m: Do not include the procedure representation in call nodes. This should make the annotated trace somewhat smaller and quicker to construct. Since this code will be executed many more times than the number of procedures whose bodies are needed by subterm dependency tracking, the overall effect of this change on speed should be positive. Instead, add code to construct procedure body representations on demand from bytecode, which is reachable indirectly through the call's node label label structure. browser/declarative_tree.m: Conform to the new structure of call nodes. compiler/prog_rep.m: Replace the code that generated the term representation of procedure bodies with code that generates a bytecode representation of procedure bodies. compiler/static_term.m: Delete this file, since it is no longer needed. compiler/notes/compiler_design.html: Document the deletion of static_term.m. mdbcomp/program_representation.m: Add the definitions related to the structure of the bytecode that are shared by the compiler and the declarative debugger. This includes the representations of determinisms. compiler/code_model.m: To prevent requiring double maintenance, use the facilities now in mdbcomp/program_representation.m to encode determinisms. runtime/mercury_stack_layout.h: compiler/layout.m: compiler/layout_out.m: compiler/opt_debug.m: compiler/stack_layout.m: Replace the proc layout field holding the procedure representation term with the field holding the procedure representation bytecode. runtime/mercury_grade.h: Record the breaking of backward compatibility in debug grades. compiler/options.m: Add an option for use by compiler implementors while implementing changes like this. runtime/mercury_trace_base.[ch]: Add the hash table that caches the results of bytecode translations. trace/mercury_trace_declarative.c: Do not include procedure representations when constructing call nodes, since it is no longer necessary. trace/mercury_trace_internal.c: Update the code that deals with procedure bodies to use the bytecode representation.	2005-03-31 04:44:33 +00:00
Zoltan Somogyi	3c60c0e485	Change a bunch of modules to import only one module per line, even ... Estimated hours taken: 4 Branches: main compiler/*.m: Change a bunch of modules to import only one module per line, even from the library. compiler/mlds_to_il.m: compiler/mlds_to_managed.m: Convert these modules to our current coding style. Use state variables where appropriate. Use predmode declarations where possible.	2005-03-22 06:40:32 +00:00
Peter Wang	59d2d4a573	This adds a module mdbcomp__trace_counts that reads in the ... Estimated hours taken: 17 Branches: main This adds a module mdbcomp__trace_counts that reads in the .mercury_trace_counts files produced by the compiler's trace mechanism. The format of said files was slightly changed. As the new module is to be used by the compiler and the debugger, it is placed in the mdbcomp module. This required bringing some types from the compiler into a new module within mdbcomp. browser/trace_counts.m: New module for reading execution trace summaries. browser/prim_data.m: New module holding types and predicates moved in from the compiler. Types: pred_or_func, sym_name, module_name, proc_label, special_pred_id, trace_port Predicates: string_to_sym_name, insert_module_qualifier The mode field of proc_label is now an int instead of a proc_id to avoid pulling proc_id into mdbcomp. browser/mdbcomp.m: Add trace_counts and prim_data to the mdbcomp module. browser/declarative_execution.m: Renamed mdb's definition of module_name to flat_module_name to avoid conflicts with the definition in mdbcomp__prim_data. runtime/mercury_trace_base.c: In the format of .mercury_trace_counts, write module and predicate names now use quoted atom syntax so that names with spaces and non-printable characters can be machine-parsed. browser/: compiler/: Many changes to account for movement of types, and the change to proc_label.	2005-01-19 03:11:22 +00:00
Zoltan Somogyi	d03ce7dbc0	Fix some bugs in my previous diff that optimized away stack slots storing ... Estimated hours taken: 8 Branches: main Fix some bugs in my previous diff that optimized away stack slots storing dummy values that manifested themselves as warnings from the C compiler about integers too big to fit into 8 or 16 bits being implicitly truncated. They did not lead to the failure of any test case, since it doesn't matter whether the debugger gets the values it ignores (I/O states or stores) from valid stack slots or not. When generating RTTI for gc and the debugger, the compiler had three places that generated references to stack slots: the return sites of calls, resume points, and trace events. The previous diff updated only the first of these. This diff updates the other two, and ensures there are no more. Since the debugger needs to know whether a procedure has a pair of I/O state arguments (e.g. when performing a retry), we add a field to proc layouts to hold this information. runtime/mercury_grade.h: Increment the debug grade runtime compatibility version number to reflect the change in layout structures. runtime/mercury_stack_layout.h: Add an extra field to proc layouts to specify flags. At the moment, the only flag says whether the procedure has a pair of I/O state arguments. Add an extra field to proc layouts to specify the trace level of a procedure. This used to be the same as the module's trace level, but one of my bug fixes a couple of months ago broke that link. We don't yet use this field, but it makes sense to do it at the same time as the increment of the compatibility version number. compiler/continuation_info.m: Attach to every description of a live value a description of where in the compiler that description was created. Rename the type involved to avoid an ambiguity. Ignore dummy types when generating resume layouts. Add some sanity checks. Add new fields to the continuation_info data structure to allow stack_layout.m to fill in the new fields in proc layout structures. compiler/trace.m: Do not generate references to dummy values at trace events, except at call ports. At those ports, all live variables should be in registers. compiler/stack_layout.m: Make the check for whether a value fits into an unsigned 8 bit value a direct rather than an indirect one. The indirect one assumed that stack slot numbers are all positive, which is now a bad assumption. Check for negative stack slot numbers in all RTTI stack slot descriptions. Fill in the two new slots in proc layout structures. compiler/layout.m: Reserve space for the two new slots in proc layout structures. compiler/layout_out.m: Output the two new slots in proc layout structures. compiler/code_gen.m: Preserve the information needed by stack_layout.m for the two new fields. compiler/llds_out.m: Add some code that ensures that we never output an integer constant that doesn't fit into the range of its type. Since this code is executed many millions of times, it is designed to be enabled only when the checking is manually enabled. It is normally off, but I got a clean bootcheck in the debug grade (which is the best stress test) with it enabled. compiler/trace_params.m: Update a comment. compiler/code_info.m: Export a function for use by trace.m. compiler/hlds_pred.m: Export a predicate for use by stack_layout.m. compiler/Mercury.options: Enable inlining for llds_out.m, to get rid of the sanity checking overhead if it is not enabled. tests/debugger/completion.exp*: tests/debugger/interpreter.exp*: tests/debugger/multi_parameter.exp*: tests/debugger/queens.exp*: tests/debugger/print_goal.exp*: tests/debugger/tabled_read.exp*: tests/debugger/tabled_read_decl.exp*: tests/debugger/declarative/io_stream_test.exp*: tests/debugger/declarative/tabled_read_decl.exp*: Update these expected output files to not expect dummy values that aren't kept anymore.	2004-11-19 05:46:25 +00:00
Zoltan Somogyi	ba38a2d1d2	Add a mechanism for collecting information about how many times each event ... Estimated hours taken: 8 Branches: main Add a mechanism for collecting information about how many times each event is executed. Later changes will exploit this information, for coverage testing and for better search strategies in the declarative debugger. runtime/mercury_stack_layout.h: Extend the module layout structure to contain a pointer to an array of counters, with one counter for each label layout structure corresponding an event. Extend label layout structures to contain the label's index into this array. The new field fits into a hole in the existing structure required by alignment considerations, so the size of label layout structures is unaffected. The memory cost of the new facility is thus only one word per event. Extend the macros for defining label layout structures to take an extra argument for the new field. runtime/mercury_grade.m: Update the binary compatibility version number for debug grades, since runtimes before this change and the compiler-generated C files in debug grades from after this change are not compatible, and neither are runtimes after this change and the compiler-generated C files in debug grades from before this change. runtime/mercury_trace_base.[ch]: Add a third alternative function to call from MR_trace; besides MR_trace_real (in the trace directory) and MR_trace_fake (in this module), add MR_trace_count, which returns after incrementing the counter of the event's label layout structure. Instead of a single variable, MR_trace_enabled, controlling whether MR_trace is enabled or not and debugging is enabled or not, use two separate variables: MR_trace_func_enabled controlling whether MR_trace is enabled or not, and MR_debug_enabled controlling whether debugging is enabled or not. MR_trace_func_enabled is always set to the disjunction of MR_debug_enabled and a new variable MR_trace_count_enabled, the variable controlling whether the facility for counting label executions is enabled. Add a function for writing out the gathered execution counts. runtime/mercury_trace_base.[ch]: trace/mercury_trace_tables.[ch]: Move the table of module_infos from mercury_trace_tables to mercury_trace_base, since the code to write out execution counts needs it. runtime/mercury_wrapper.c: When MERCURY_OPTIONS contains --trace-count and debugging is not, enable the mechanism for counting the execution of events, and write out the results. library/exception.m: library/io.m: library/table_builtin.m: runtime/mercury_tabling_preds.h: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Conform to the changes involving the replacement of MR_trace_enabled. tools/bootcheck: Add an new option, --trace-count, for enabling the new mechanism. compiler/layout.m: Change the compiler's data structures for label layouts and module layouts to conform to the changes in mercury_stack_layout.h. compiler/layout_out.m: Update the code for writing out label layouts and module layouts. compiler/stack_layout.m: Allocate slots in the execution count array to the label layout structures of all events. Delete the unnecessary last arguments of `get' field access predicates. compiler/llds_out.m: compiler/opt_debug.m: Conform to the changes in layout.m.	2004-08-16 03:51:16 +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	4954da84cc	Reduce the dependence of the MLDS backend on the LLDS backend by moving ... Estimated hours taken: 2 Branches: main Reduce the dependence of the MLDS backend on the LLDS backend by moving functionality dealing with proc_labels from the LLDS backend (code_util.m) to a new module, proc_label.m, which is part of backend_libs. compiler/code_util.m: compiler/proc_label.m: Move a type and some code from code_util to the new module. Convert predicates to functions as relevant. (The old code was written before functions were available). compiler/backend_libs.m: Add proc_label to the list of submodules. compiler/rtti.m: Rename a function to avoid a name clash with a function in proc_label.m. compiler/*.m: Conform to the changes above. Ensure that all imports of modules in the compiler directory are on lines of their own, to make CVS merges easier. Sort the imports.	2003-03-14 08:10:12 +00:00
Fergus Henderson	90d353d06c	Implement concat_strings in Mercury. ... Estimated hours taken: 2 Branches: main compiler/stack_layout.m: Implement concat_strings in Mercury. compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Use a separate type `string_with_0s' rather than `string' for strings which may contain null characters.	2003-02-16 02:14:16 +00:00
Zoltan Somogyi	2bef47ce85	Extend the information we record about procedures when debugging is enabled ... Estimated hours taken: 20 Branches: main (for now, after more testing, on release branch too) Extend the information we record about procedures when debugging is enabled to include information about the tabling transformation, if the procedure in question is tabled. This is useful to developers in debugging the tabling mechanism, and can be useful to general users by helping them understand the space (and hence time) costs of tabling. Add a new mdb command "table" that uses this information to print programmer-selected subsets of the tables of a tabled procedure. compiler/hlds_pred.m: Generalize the existing field in procedures that used to hold information about I/O tabling to contain information about tabling in general, including forms other than I/O tabling. compiler/continuation_info.m: compiler/code_gen.m: compiler/stack_layout.m: Conform to the changes in hlds_pred.m. compiler/layout.m: Provide Mercury parallels for the new data structures in mercury_stack_layout.h. compiler/layout_out.m: Generate the new data structures in mercury_stack_layout.h. compiler/table_gen.m: Generate the new data structures in hlds_pred.m. compiler/llds_common.m: compiler/opt_debug.m: Conform to the changes in layout.m compiler/llds_out.m: Abstract out existing code into a new procedure to make it available to layout_out.m. Make tabling pointer variables their natural type. compiler/modules.m: Fix an old bug: implicitly import table_builtin.m in .mm grades. doc/mdb_categories: doc/user_guide.texi: Document the new mdb command "table". runtime/mercury_types.h: Move some type definitions here from mercury_tabling.h and mercury_stack_layout.h. This was necessary to avoid problems with circular #includes, in which a.h #includes b.h to get access to a definition, but b.h #includes a.h, which is prevented by the macro guarding against duplicate definition, which causes syntax errors in the rest of b.h because the rest of b.h depends on typedefs in a.h that occur in a.h *after* the #include of b.h. runtime/mercury_label.h: Adjust the list of #includes after the change to mercury_types.h. runtime/mercury_stack_layout.h: Extend the debugging data structures with constructs that describe the call tables, answer tables and answer blocks of tabled procedures. Delete typedefs that are now in mercury_types.h. runtime/mercury_tabling.[ch]: Add new functions to allow lookups without insertions in hash tables containing ints, floats and strings. Add new functions to return the entire contents of these hash tables. Change to four-space indentation where this wasn't done previously. runtime/mercury_grade.h: Increment the binary compatbility version number, partially to account for the change to mercury_stack_layout.h in this diff, but mostly to account for all the other diffs to mercury_stack_layout.h since the last released version. trace/mercury_trace_tables.[ch]: Rename MR_print_proc_id_for_debugger as MR_print_proc_id_and_nl, since this better describes what the function does. trace/mercury_trace_util.[ch]: Add a new function MR_trace_is_integer that reads in signed integers. Rename MR_trace_is_number as MR_trace_is_natural_number, since the former would now be ambiguous. Add a new function MR_trace_is_float that reads in floating point values. library/string.m: Document that MR_trace_is_float uses the same logic as MR_trace_is_float. trace/mercury_trace_browse.c: trace/mercury_trace_vars.c: Update calls to MR_trace_is_number. trace/mercury_trace_internal.c: Implement the new mdb command "table". Update calls to MR_trace_is_number and to MR_print_proc_id_for_debugger. tests/debugger/print_table.{m,inp,exp}: New test case to test the new mdb command. tests/debugger/Mmakefile: Enable the new test case. Disable the sensitive test cases in .mm grades. tests/debugger/completion.exp: Update the expected output to include the new mdb command. tests/debugger/mdb_command_test.inp: Update this automatically generated file to include the new mdb command.	2002-11-15 04:50:49 +00:00
Zoltan Somogyi	bdbf93e971	Delete trace level decl, since there was only a very small distinction ... Estimated hours taken: 4 Branches: main Delete trace level decl, since there was only a very small distinction left between it and trace level deep, to wit, you could suppress events in trace level deep but not in trace level decl. Implement the relevant test more precisely by checking whether any event types *were* suppressed, as opposed to whether they *could have been* suppressed. Preserve the user interface by making --trace decl a synonym for --trace rep. compiler/layout.m: Include an integer encoding the set of suppressed event types in the module layout structures. compiler/trace_params.m: Add a function for computing this encoded integer. Delete trace level decl. compiler/stack_layout.m: Call that function when creating module layouts. compiler/layout_out.m: compiler/llds_out.m: compiler/llds_common.m: Handle the extra field in module layouts. doc/user_guide.texi: Delete or comment out all mentions of --trace decl and decldebug grades. runtime/mercury_trace_base.h: Update the list of places that know about the set of events. runtime/mercury_stack_layout.h: Delete trace level decl. Include an integer encoding the set of suppressed event types in the module layout structures. trace/mercury_trace_declarative.c: Accept trace level deep without any suppressed event types as sufficient to enable declarative debugging. tests/debugger/declarative/Mercury.options: Now that trace level deep is sufficient for declarative debugging, suppress the event types that weren't part of the old trace level deep, in order to elicit the warning message we are testing. tests/debugger/declarative/deep_warning.exp: Update the text of the warning message.	2002-09-29 10:30:59 +00:00
Zoltan Somogyi	37e1c49f78	Implement a flag that can be used by the compiler to signal to the debugger ... Estimated hours taken: 1 Branches: main Implement a flag that can be used by the compiler to signal to the debugger that some events should be hidden from the user. The flag is not used yet. compiler/continuation_info.m: compiler/layout.m: Make room for the flag in the data structures storing information about events. compiler/layout_out.m: Output the flag in label layouts. runtime/mercury_stack_layout.h: Define a field for the flag in label layouts. compiler/trace.m: Specify "no" as the value of the hidden flag, for now. Later, when we add hidden events, we will specify "yes" for them. compiler/code_info.m: compiler/stack_layout.m: Pass on the value of the hidden flag.	2002-08-30 07:24:49 +00:00
Mark Brown	0b2c0c6b6c	Remove the code that reserves two stack slots for declarative debugging. ... Estimated hours taken: 0.5 Branches: main Remove the code that reserves two stack slots for declarative debugging. Now that code for MR_USE_DECL_STACK_SLOT no longer exists, there is no chance that the stack slots will be required. compiler/layout.m: Remove the maybe_decl_debug_slot field from proc_layout_exec_trace. compiler/layout_out.m: Don't print the field that was just removed. Update a couple of comments. compiler/trace.m: Remove the slot_decl field from trace_slot_info. Don't reserve the two slots. compiler/llds_common.m: compiler/code_info.m: compiler/stack_layout.m: Propagate the effects of the above changes. compiler/trace_params.m: Remove trace_level_needs_decl_debug_slots. runtime/mercury_stack_layout.h: Remove the MR_exec_maybe_decl_debug field from MR_Exec_Trace. runtime/mercury_conf_param.h: Don't document MR_USE_DECL_STACK_SLOT. trace/mercury_trace_declarative.c: Remove the prototypes of two unused functions whose definitions were removed earlier.	2002-05-16 13:14:54 +00:00
Zoltan Somogyi	f6f04fb5b3	To handle the tracing of dependencies in polymorphic predicates, the ... Estimated hours taken: 4 Branches: main To handle the tracing of dependencies in polymorphic predicates, the declarative debugger will soon need to know, for each procedure, the full list of that procedure's head variables, not just the list of programmer-created head variables. To this end, we add to each procedure's layout structure a vector of the head variables' variable numbers. Code to make use of this new vector will be in a later change. compiler/layout.m; Add a way to refer to the head variable number vector. compiler/layout_out.m; compiler/opt_debug.m; Add code to output the head variable number vector. compiler/stack_layout.m; Add code to generate the head variable number vector. Fix some old variable names. runtime/mercury_stack_layout.h; Add the head variable number vector to procedure layouts. Add some missing documentation.	2002-04-12 10:08:24 +00:00
Fergus Henderson	7597790760	Use sub-modules to structure the modules in the Mercury compiler directory. ... The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c.	2002-03-20 12:37:56 +00:00
Zoltan Somogyi	13f0e7610a	A large step towards declarative debugging of goals that do I/O. ... Estimated hours taken: 40 Branches: main A large step towards declarative debugging of goals that do I/O. This step does everything needed for that except modify the declarative debugger itself; that is for Mark to do. If you give the new option --trace-table-io-decl, the transformation performed by the compiler on I/O primitives will preserve not just the output arguments of the primitive, so that the primitive can be "reexecuted" without performing any side-effects, but also the input arguments and the identity of the I/O primitive itself. The I/O table therefore will contain a list of the I/O primitives executed by the program after I/O tabling is started. You can test this via the new debugger commands "print action <action-number>" and "browse action <action-number>". The new option is currently not documented, because the declarative debugger does not yet use the information it provides. The new debugger commands are not documented because they are meant only for implementors, at least for now. Since this change adds a field to proc_layout structures, any workspaces compiled with debugging enabled will need to do a cvs update when this change is installed. compiler/options.m: Add the option --trace-table-io-decl. When set, this causes the compiler to transform I/O action primitives to allow declarative debugging of I/O actions. compiler/handle_options.m: Make --trace-table-io-decl imply --trace-table-io. compiler/table_gen.m: Perform the transformation, which is similar to the existing --trace-table-io transformation, but preserves the identity of all non-io-state arguments (not just the outputs) and the identity of the I/O primitive itself. Provide better names for variables generated by tabling transformations. compiler/hlds_goal.m: Add extra parameters to procedures whose job it is to create new goals to name the variables in those goals. compiler/layout.m: Add a new layout structure to contain the information the runtime system needs to interpret the information saved by the new transformation. compiler/layout_out.m: Output the new layout structure. compiler/continuation_info.m: Add a field to proc_layouts to point to the declarative I/O tabling structure, and another to identify the proc_layout without using LLDS types. compiler/code_gen.m: Provide the definition of this field when appropriate. compiler/hlds_pred.m: Add a field to proc_infos to store the information from the tabling transformation until code generation. compiler/stack_layout.m: Add a mechanism for transforming the high level description of I/O action tabling data in proc_infos to the low level description we need to generate C data structures. compiler/hlds_data.m: Add a new cons_id and a new cons_tag; they are used to refer to I/O tabling structures in code generated by the new transformation. compiler/*.m: Handle the updates to global data types above. library/table_builtin.m: Modernize some old code. Fix an old off-by-one error: make I/O tabling use the first slot in the I/O action table. library/varset.m: Add a mechanism for creating a variable that is named iff the caller has a name for it. runtime/mercury_layout_util.[ch]: Add a function for materializing type parameters from an answer block, not from registers or a closure. runtime/mercury_stack_layout.h: Declare a C type for the data structure holding information about I/O primitives transformed by --trace-table-io-decl, and add a field to proc_layout structures to point to these new structures. Add a new evaluation method for --trace-table-io-decl. runtime/mercury_tabling_macros.h: Add some conditionally-compiled debugging code to the primitive for saving answers. trace/mercury_trace_vars.[ch]: Add functions for printing I/O action goals. trace/mercury_trace_internal.c: Add code for recognizing and implementing commands to print I/O action goals. trace/mercury_trace.c: Add code for handling the new eval method. tests/debugger/tabled_read.{m,inp,exp*}: Add a polymorphic I/O action primitive, add calls to it, and test the printing of both monomorphic and polymorphic action goals. tests/debugger/tabled_read_decl.{m,inp,exp*,data}: A new test case. It does the same things as the new version of tabled_read, but it is compiled with --trace-table-io-decl, not just --trace-table-io. It therefore can (and does) test the printing of tabled I/O actions. tests/debugger/Mmakefile: Add the new test case.	2002-02-20 03:14:51 +00:00
Zoltan Somogyi	a9fed43d57	Major enhancements of the deep profiler. The most important ones are: ... Estimated hours taken: 80 Branches: main Major enhancements of the deep profiler. The most important ones are: - The addition of several new classes of preferences, including: the use of colour, boxing, sorting, summarizing of higher order call sites, and time formats. - Making preferences persistent across different queries, so that once a preference is set, it "sticks" until the user changes it. Previously, preferences stuck during query sequences of the same command type. - Several new command types: - listing all the modules of the program - listing all the procedures in a module - listing all the callers of a procedure, grouped by calling call site, procedure, module, or clique, and filtering out certain classes of ancestors - jumping into the call graph close to the action - restarting the server (useful when the data file changes) - New optional columns showing time per call, allocations per call and words allocated per call. - Can now display memory consumption in bytes as well as words. - More robustness in the face of external events, e.g. machine shutdowns. - Fix a bug reported by Tom in the summaries of procedures that make higher order calls. The new functionality required adding some fields to ProcStatic structures; as a result, compilers and runtime systems that have this change are incompatible with compilers and runtime systems before this change in deep profiling grades. (They of course remain compatible in other grades.) compiler/deep_profiling.m: compiler/layout.m: compiler/layout_out.m: Add two new fields to ProcStatic structures, one giving the line number of procedure's context and one stating whether the procedure is exported from its module. compiler/layout.m: Be consistent about filename vs file_name in field names. compiler/*.m: Minor changes to handle the new fields. deep_profiler/interface.m: Define new command types, modify some of the parameters of existing ones, and delete obsolete ones. Define the types and predicates used by the new system of preferences, Update the predicates for recognizing and generating queries accordingly. Make the order of declarations and definitions more consistent. deep_profiler/split.m: Complete rewrite of the only predicate of this module. The old split predicate deleted any empty substrings resulting from the breakup of the original string. The new one preserves them, because they are needed by the new encoding scheme used in interface.m. deep_profiler/query.m: New module, containing code dealing with the computational issues of queries. Some of its code is old (from server.m), much of it is new. deep_profiler/html_format.m: New module, containing code dealing with HTML formatting. Some of its code is old (from server.m), much of it is new. deep_profiler/top_procs.m: New module, containing code dealing with issues involving sorting by various criteria. Some of its code is old (from server.m), much of it is new. deep_profiler/exclude.m: New module to handle contour exclusion. This means that when listing the callers of a procedure, we display the nearest parent that is *not* excluded by virtue of being in a given module. The set of modules so excluded forms a contour drawn through the program. deep_profiler/mdprof_cgi.m: deep_profiler/mdprof_server.m: deep_profiler/server.m: Minor changes to adapt to the new system of preferences. deep_profiler/array_util.m: Add a mode to foldl2. deep_profiler/io_combinator.m: Add predicates for reading in sequences of ten things. deep_profiler/measurements.m: Add a function needed by new code. deep_profiler/timeout.m: Make the profiler robust in the face of signals. deep_profiler/canonical.m: Some more work towards working canonicalization; not there yet. Move some procedures to profile.m, since other modules also need them now. deep_profiler/profile.m: Add the new fields to ProcStatic structures. Record the word size. Record more information about procedures whose activation counters are ever zeroed, in order to allow query.m to avoid giving misleading information in cases where a procedure calls itself through a higher order call site. Record information about the modules of the program. Add a bunch of lookup predicates, some moved from canonical.m. deep_profiler/call_graph.m: Minor changes to conform to changes in profile.m. deep_profiler/startup.m: Fill in the new parts of the profile data structure. deep_profiler/read_profile.m: Read the new fields in ProcStatic structures. Read in the id of the root node as a fixed part of the header, not as a node. Read in the word size. Make it easier to find all the debugging output sites. Record, for each call site which can call more than one procedure, whether this causes the caller's ProcStatic structure's activation count to be zeroed. runtime/mercury_deep_profiling.h: Add the new fields to ProcStatic structures. runtime/mercury_deep_profiling.c: Write out the new fields to ProcStatic structures. Write out the id of the root node as a fixed part of the header, not as a node. Write out the word size. Remove incorrect L suffixes on constants. Record that the artificial procedure "parent of main" is called once, not zero times, to avoid division by zero when computing per-call statistics. runtime/mercury_deep_profiling_hand.h: Add the new fields to the macros for creating ProcStatic structures. runtime/mercury_ho_call.c: library/array.m: library/builtin.m: library/exception.m: library/std_util.m: Add the new fields to the invocations of those macros.	2001-07-03 08:16:33 +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	2498d9d3fd	Instead of generating the layout structures of labels, procs and modules ... Estimated hours taken: 36 Instead of generating the layout structures of labels, procs and modules as rvals, generate them almost entirely as C structures. This will make future modifications much easier, since mismatches between what the runtime expects and what the compiler generates will now be pointed out by the C compiler. (It also reduces the size of the C source files generated with debugging enabled by about 5%.) Layout structures contain a few components that are not well-typed in C; we continue to generate these as rvals. Closure layout structures used to have a well-typed part and a non-well-typed part. We now generate the well-typed part as a separate structure, pointed to from the other. We also extend the well-typed part, so that instead of just giving the name the called procedure, it also identifies the source location where the closure was constructed. This could be useful for the debugger and for deep profiling. This diff also includes a change to get the compiler to bootstrap with lcc in grade none.gc.debug.tr: initializing the string tables in module layouts not as a string but as an array of characters. runtime/mercury_stack_layout.h: Reorganize the definitions of layout structures. Rename Stack_Layout_Entry structures as Proc_Layout structures, and Stack_Layout_Label structures as Label_Layout structures. (The debugger paper refers to the structures by the new names.) Fold the Stack_Layout_Vars structure into the structure that contains it, the Label_Layout structure. Add a Closure_Id structure that contains a Proc_Id structure as well as extra information identifying the source location where the closure was created. Create "short" versions of the Proc_Layout structures, which contain only the first one or two of the three groups of fields. Previously, the Mercury compiler would define new C types when it generated such short structures. Since we are not defining new C types anymore, there must be a C type for every kind of structure the Mercury compiler can generate. We now also have separate variants for the layouts of user-defined and compiler-generated procedures, since the format of their procedure id information is different. While the runtime system refers to their procedure id information through a union, the C types of the structures generated by the Mercury compiler do not use a union, since a union cannot be initialized through its second member. Make the constant fields of structures const, since we now generate values of those structure types, and initialize them with constant data. Move the documentation of layout structures here from stack_layout.m. runtime/mercury_ho_call.h: Instead of bodily including an MR_Proc_Id structure in closures, include a pointer to the more detailed MR_Closure_Id structure. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_init.h: runtime/mercury_label.[ch]: runtime/mercury_layout_util.[ch]: Minor updates to conform to changes in mercury_stack_layout.h. runtime/mercury_goto.h: Use separate naming schemes for label layout structures and proc layout structures. library/exception.m: Minor updates to conform to changes in mercury_stack_layout.h. compiler/layout.m: A new module that defines data structures for label, proc and module layout structures and for closure id structures. compiler/layout_out.m: A new module that converts the Mercury data structures of layout.m into declarations and definitions of C data structures. compiler/stack_layout.m: Generate the new layout structures instead of rvals. Move the documentation of layout structures from here to runtime/mercury_stack_layout.h, since this module is no longer aware of some of their details. compiler/llds.m: Make layout structures a separate kind of compiler-generated data. compiler/llds_out.m: Remove the code for the output of layout structures; call layout_out.m instead. compiler/llds_out.m: compiler/rtti_out.m: Turn some predicates into functions. compiler/code_gen.m: compiler/code_info.m: compiler/llds.m: compiler/mercury_compile.m: compiler/unify_gen.m: Instead of handling closure layouts like other static data, handle them separately. Add a counter to the code_info structure in order to allow closure id structures to be identified uniquely by a pair consisting of the id of the procedure that generates them and a closure sequence number within that procedure. compiler/llds_common.m: Look for common rvals among the rvals in layout structures. compiler/opt_debug.m: Generate developer-friendly names for layout structure references. browser/dl.m: Update the code for constructing closure layouts.	2001-01-18 01:19:17 +00:00