mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-13 21:04:00 +00:00
Aditi compilation.
Estimated hours taken: 1200
Aditi compilation.
compiler/options.m:
The documentation for these is commented out because the Aditi
system is not currently useful to the general public.
--aditi: enable Aditi compilation.
--dump-rl: write the intermediate RL to `<module>.rl_dump'.
--dump-rl-bytecode: write a text version of the bytecodes
to `<module>.rla'
--aditi-only: don't produce a `.c' file.
--filenames-from-stdin: accept a list of filenames to compile
from stdin. This is used by the query shell.
--optimize-rl, --optimize-rl-cse, --optimize-rl-invariants,
--optimize-rl-index, --detect-rl-streams:
Options to control RL optimization passes.
--aditi-user:
Default owner of any Aditi procedures,
defaults to $USER or "guest".
--generate-schemas:
write schemas for base relations to `<module>'.base_schema
and schemas for derived relations to `<module>'.derived_schema.
This is used by the query shell.
compiler/handle_options.m:
Handle the default for --aditi-user.
compiler/hlds_pred.m:
compiler/prog_data.m:
compiler/prog_io_pragma.m:
compiler/make_hlds.m:
Add some Aditi pragma declarations - `aditi', `supp_magic', `context',
`naive', `psn' (predicate semi-naive), `aditi_memo', `aditi_no_memo',
`base_relation', `owner' and `index'.
Separate out code to parse a predicate name and arity.
compiler/hlds_pred.m:
Add predicates to identify Aditi procedures.
Added markers `generate_inline' and `aditi_interface', which
are used internally for Aditi code generation.
Add an `owner' field to pred_infos, which is used for database
security checks.
Add a field to pred_infos to hold the list of indexes for a base
relation.
compiler/make_hlds.m:
Some pragmas must be exported if the corresponding predicates
are exported, check this.
Make sure stratification of Aditi procedures is checked.
Predicates with a mode declaration but no type declaration
are no longer assumed to be local.
Set the `do_aditi_compilation' field of the module_info if there
are any local Aditi procedures or base relations.
Check that `--aditi' is set if Aditi compilation is required.
compiler/post_typecheck.m:
Check that every Aditi predicate has an `aditi__state' argument,
which is used to ensure sequencing of updates and that Aditi
procedures are only called within transactions.
compiler/dnf.m:
Changed the definition of disjunctive normal form slightly
so that a call followed by some atomic goals not including
any database calls is considered atomic. magic.m can handle
this kind of goal, and it results in more efficient RL code.
compiler/hlds_module.m:
compiler/dependency_graph.m:
Added dependency_graph__get_scc_entry_points which finds
the procedures in an SCC which could be called from outside.
Added a new field to the dependency_info, the
aditi_dependency_ordering. This contains all Aditi SCCs of
the original program, with multiple SCCs merged where
possible to improve the effectiveness of differential evaluation
and the low level RL optimizations.
compiler/hlds_module.m:
Add a field to record whether there are any local Aditi procedures
in the current module.
Added versions of module_info_pred_proc_info and
module_info_set_pred_proc_info which take a pred_proc_id,
not a separate pred_id and proc_id.
compiler/polymorphism.m:
compiler/lambda.m:
Make sure that predicates created for closures in Aditi procedures
have the correct markers.
compiler/goal_util.m:
Added goal_util__switch_to_disjunction,
goal_util__case_to_disjunct (factored out from simplify.m)
and goal_util__if_then_else_to_disjunction. These are
require because supplementary magic sets can't handle
if-then-elses or switches.
compiler/type_util.m:
Added type_is_aditi_state/1.
compiler/mode_util.m:
Added partition_args/5 which partitions a list of arguments
into inputs and others.
compiler/inlining.m:
Don't inline memoed procedures.
Don't inline Aditi procedures into non-Aditi procedures.
compiler/intermod.m:
Handle Aditi markers.
Clean up handling of markers which should not appear in `.opt' files.
compiler/simplify.m:
Export a slightly different interface for use by magic.m.
Remove explicit quantifications where possible.
Merge multiple nested quantifications.
Don't report infinite recursion warnings for Aditi procedures.
compiler/prog_out.m:
Generalised the code to output a module list to write any list.
compiler/code_gen.m:
compiler/arg_info.m:
Don't process Aditi procedures.
compiler/mercury_compile.m:
Call magic.m and rl_gen.m.
Don't perform the low-level annotation passes on Aditi procedures.
Remove calls to constraint.m - sometime soon a rewritten version
will be called directly from deforestation.
compiler/passes_aux.m:
Add predicates to process only non-Aditi procedures.
compiler/llds.m:
compiler/llds_out.m:
Added new `code_addr' enum members, do_{det,semidet,nondet}_aditi_call,
which are defined in extras/aditi/aditi.m.
compiler/call_gen.m:
Handle generation of do_*_aditi_call.
compiler/llds_out.m:
Write the RL code for the module as a constant char array
in the `.c' file.
compiler/term_errors.m:
compiler/error_util.m:
Move code to describe predicates into error_util.m
Allow the caller to explicitly add line breaks.
Added error_util:list_to_pieces to format a list of
strings.
Reordered some arguments for currying.
compiler/hlds_out.m:
Don't try to print clauses if there are none.
runtime/mercury_init.h:
util/mkinit.c:
scripts/c2init.in:
Added a function `mercury__load_aditi_rl_code()' to the generated
`<module>_init.c' file which throws all the RL code for the program
at the database. This should be called at connection time by
`aditi__connect'.
Added an option `--aditi' which controls the output
`mercury__load_aditi_rl_code()'.
compiler/notes/compiler_design.html:
Document the new files.
Mmakefile:
bindist/Mmakefile:
Don't distribute extras/aditi yet.
New files:
compiler/magic.m:
compiler/magic_util.m:
Supplementary magic sets transformation. Report errors
for constructs that Aditi can't handle.
compiler/context.m:
Supplementary context transformation.
compiler/rl_gen.m:
compiler/rl_relops.m:
Aditi code generation.
compiler/rl_info.m:
Code generator state.
compiler/rl.m:
Intermediate RL representation.
compiler/rl_util:
Predicates to collect information about RL instructions.
compiler/rl_dump.m:
Print out the representation in rl.m.
compiler/rl_opt.m:
Control low-level RL optimizations.
compiler/rl_block.m:
Break a procedure into basic blocks.
compiler/rl_analyse.m:
Generic dataflow analysis for RL procedures.
compiler/rl_liveness.m:
Make sure all relations are initialised before used, clear
references to relations that are no longer required.
compiler/rl_loop.m:
Loop invariant removal.
compiler/rl_block_opt.m:
CSE and instruction merging on basic blocks.
compiler/rl_key.m:
Detect upper/lower bounds for which a goal could succeed.
compiler/rl_sort.m:
Use indexing for joins and projections.
Optimize away unnecessary sorting and indexing.
compiler/rl_stream.m:
Detect relations which don't need to be materialised.
compiler/rl_code.m:
RL bytecode definitions. Automatically generated from the Aditi
header files.
compiler/rl_out.m:
compiler/rl_file.m:
Output the RL bytecodes in binary to <module>.rlo (for use by Aditi)
and in text to <module>.rla (for use by the RL interpreter).
Also output the schema information if --generate-schemas is set.
compiler/rl_exprn.m:
Generate bytecodes for join conditions.
extras/aditi/Mmakefile:
extras/aditi/aditi.m:
Definitions of some Aditi library predicates and the
interfacing and transaction processing code.
This commit is contained in:
Simon Taylor
@@ -22,7 +22,7 @@
|
||||
|
||||
:- implementation.
|
||||
|
||||
:- import_module prog_io, prog_io_goal, hlds_pred, term_util, term_errors.
|
||||
:- import_module prog_io, prog_io_goal, hlds_pred, term_util, term_errors, rl.
|
||||
:- import_module int, map, string, std_util, bool, require.
|
||||
|
||||
parse_pragma(ModuleName, VarSet, PragmaTerms, Result) :-
|
||||
@@ -494,36 +494,21 @@ parse_pragma_type(ModuleName, "fact_table", PragmaTerms, ErrorTerm,
|
||||
(
|
||||
PragmaTerms = [PredAndArityTerm, FileNameTerm]
|
||||
->
|
||||
parse_pred_name_and_arity(ModuleName, "fact_table",
|
||||
PredAndArityTerm, ErrorTerm, NameArityResult),
|
||||
(
|
||||
PredAndArityTerm = term__functor(term__atom("/"),
|
||||
[PredNameTerm, ArityTerm], _)
|
||||
->
|
||||
(
|
||||
parse_implicitly_qualified_term(ModuleName,
|
||||
PredNameTerm, PredAndArityTerm,
|
||||
"pragma fact_table declaration", ok(PredName, [])),
|
||||
ArityTerm = term__functor(term__integer(Arity), [], _)
|
||||
NameArityResult = ok(PredName, Arity),
|
||||
(
|
||||
FileNameTerm = term__functor(term__string(FileName), [], _)
|
||||
->
|
||||
(
|
||||
FileNameTerm =
|
||||
term__functor(term__string(FileName), [], _)
|
||||
->
|
||||
Result = ok(pragma(fact_table(PredName, Arity,
|
||||
FileName)))
|
||||
;
|
||||
Result = error(
|
||||
"expected string for fact table filename",
|
||||
FileNameTerm)
|
||||
)
|
||||
Result = ok(pragma(fact_table(PredName, Arity, FileName)))
|
||||
;
|
||||
Result = error(
|
||||
"expected predname/arity for `pragma fact_table(..., ...)'",
|
||||
PredAndArityTerm)
|
||||
Result = error("expected string for fact table filename",
|
||||
FileNameTerm)
|
||||
)
|
||||
;
|
||||
Result = error(
|
||||
"expected predname/arity for `pragma fact_table(..., ...)'",
|
||||
PredAndArityTerm)
|
||||
NameArityResult = error(ErrorMsg, _),
|
||||
Result = error(ErrorMsg, PredAndArityTerm)
|
||||
)
|
||||
;
|
||||
Result =
|
||||
@@ -532,6 +517,122 @@ parse_pragma_type(ModuleName, "fact_table", PragmaTerms, ErrorTerm,
|
||||
ErrorTerm)
|
||||
).
|
||||
|
||||
parse_pragma_type(ModuleName, "aditi", PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "aditi",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = aditi(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "base_relation", PragmaTerms,
|
||||
ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "base_relation",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = base_relation(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "aditi_index", PragmaTerms,
|
||||
ErrorTerm, _, Result) :-
|
||||
( PragmaTerms = [PredNameArityTerm, IndexTypeTerm, AttributesTerm] ->
|
||||
parse_pred_name_and_arity(ModuleName, "aditi_index",
|
||||
PredNameArityTerm, ErrorTerm, NameArityResult),
|
||||
(
|
||||
NameArityResult = ok(PredName, PredArity),
|
||||
(
|
||||
IndexTypeTerm = term__functor(term__atom(IndexTypeStr),
|
||||
[], _),
|
||||
(
|
||||
IndexTypeStr = "unique_B_tree",
|
||||
IndexType = unique_B_tree
|
||||
;
|
||||
IndexTypeStr = "non_unique_B_tree",
|
||||
IndexType = non_unique_B_tree
|
||||
)
|
||||
->
|
||||
convert_int_list(AttributesTerm, AttributeResult),
|
||||
(
|
||||
AttributeResult = ok(Attributes),
|
||||
Result = ok(pragma(aditi_index(PredName, PredArity,
|
||||
index_spec(IndexType, Attributes))))
|
||||
;
|
||||
AttributeResult = error(_, AttrErrorTerm),
|
||||
Result = error(
|
||||
"expected attribute list for `:- pragma aditi_index(...)' declaration",
|
||||
AttrErrorTerm)
|
||||
)
|
||||
;
|
||||
Result = error(
|
||||
"expected index type for `:- pragma aditi_index(...)' declaration",
|
||||
IndexTypeTerm)
|
||||
)
|
||||
;
|
||||
NameArityResult = error(NameErrorMsg, NameErrorTerm),
|
||||
Result = error(NameErrorMsg, NameErrorTerm)
|
||||
)
|
||||
;
|
||||
Result = error(
|
||||
"wrong number of arguments in pragma aditi_index(..., ..., ...) declaration",
|
||||
ErrorTerm)
|
||||
).
|
||||
|
||||
parse_pragma_type(ModuleName, "naive", PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "naive",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = naive(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "psn", PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "psn",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = psn(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "aditi_memo",
|
||||
PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "aditi_memo",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = aditi_memo(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "aditi_no_memo",
|
||||
PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "aditi_no_memo",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = aditi_no_memo(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "supp_magic",
|
||||
PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "supp_magic",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = supp_magic(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "context",
|
||||
PragmaTerms, ErrorTerm, _, Result) :-
|
||||
parse_simple_pragma(ModuleName, "context",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = context(Name, Arity)),
|
||||
PragmaTerms, ErrorTerm, Result).
|
||||
|
||||
parse_pragma_type(ModuleName, "owner",
|
||||
PragmaTerms, ErrorTerm, _, Result) :-
|
||||
( PragmaTerms = [SymNameAndArityTerm, OwnerTerm] ->
|
||||
( OwnerTerm = term__functor(term__atom(Owner), [], _) ->
|
||||
parse_simple_pragma(ModuleName, "owner",
|
||||
lambda([Name::in, Arity::in, Pragma::out] is det,
|
||||
Pragma = owner(Name, Arity, Owner)),
|
||||
[SymNameAndArityTerm], ErrorTerm, Result)
|
||||
;
|
||||
string__append_list(["expected owner name for
|
||||
`pragma owner(...)' declaration"], ErrorMsg),
|
||||
Result = error(ErrorMsg, OwnerTerm)
|
||||
)
|
||||
;
|
||||
string__append_list(["wrong number of arguments in
|
||||
`pragma owner(...)' declaration"], ErrorMsg),
|
||||
Result = error(ErrorMsg, ErrorTerm)
|
||||
).
|
||||
|
||||
parse_pragma_type(ModuleName, "promise_pure", PragmaTerms, ErrorTerm,
|
||||
_VarSet, Result) :-
|
||||
parse_simple_pragma(ModuleName, "promise_pure",
|
||||
@@ -645,29 +746,15 @@ parse_pragma_type(ModuleName, "check_termination", PragmaTerms,
|
||||
|
||||
parse_simple_pragma(ModuleName, PragmaType, MakePragma,
|
||||
PragmaTerms, ErrorTerm, Result) :-
|
||||
(
|
||||
PragmaTerms = [PredAndArityTerm]
|
||||
->
|
||||
( PragmaTerms = [PredAndArityTerm] ->
|
||||
parse_pred_name_and_arity(ModuleName, PragmaType,
|
||||
PredAndArityTerm, ErrorTerm, NameArityResult),
|
||||
(
|
||||
PredAndArityTerm = term__functor(term__atom("/"),
|
||||
[PredNameTerm, ArityTerm], _)
|
||||
->
|
||||
(
|
||||
parse_implicitly_qualified_term(ModuleName,
|
||||
PredNameTerm, ErrorTerm, "", ok(PredName, [])),
|
||||
ArityTerm = term__functor(term__integer(Arity), [], _)
|
||||
->
|
||||
call(MakePragma, PredName, Arity, Pragma),
|
||||
Result = ok(pragma(Pragma))
|
||||
;
|
||||
string__append_list(
|
||||
["expected predname/arity for `pragma ",
|
||||
PragmaType, "(...)' declaration"], ErrorMsg),
|
||||
Result = error(ErrorMsg, PredAndArityTerm)
|
||||
)
|
||||
NameArityResult = ok(PredName, Arity),
|
||||
call(MakePragma, PredName, Arity, Pragma),
|
||||
Result = ok(pragma(Pragma))
|
||||
;
|
||||
string__append_list(["expected predname/arity for `pragma ",
|
||||
PragmaType, "(...)' declaration"], ErrorMsg),
|
||||
NameArityResult = error(ErrorMsg, _),
|
||||
Result = error(ErrorMsg, PredAndArityTerm)
|
||||
)
|
||||
;
|
||||
@@ -676,6 +763,34 @@ parse_simple_pragma(ModuleName, PragmaType, MakePragma,
|
||||
Result = error(ErrorMsg, ErrorTerm)
|
||||
).
|
||||
|
||||
:- pred parse_pred_name_and_arity(module_name, string, term, term,
|
||||
maybe2(sym_name, arity)).
|
||||
:- mode parse_pred_name_and_arity(in, in, in, in, out) is det.
|
||||
|
||||
parse_pred_name_and_arity(ModuleName, PragmaType, PredAndArityTerm,
|
||||
ErrorTerm, Result) :-
|
||||
(
|
||||
PredAndArityTerm = term__functor(term__atom("/"),
|
||||
[PredNameTerm, ArityTerm], _)
|
||||
->
|
||||
(
|
||||
parse_implicitly_qualified_term(ModuleName,
|
||||
PredNameTerm, ErrorTerm, "", ok(PredName, [])),
|
||||
ArityTerm = term__functor(term__integer(Arity), [], _)
|
||||
->
|
||||
Result = ok(PredName, Arity)
|
||||
;
|
||||
string__append_list(
|
||||
["expected predname/arity for `pragma ",
|
||||
PragmaType, "(...)' declaration"], ErrorMsg),
|
||||
Result = error(ErrorMsg, PredAndArityTerm)
|
||||
)
|
||||
;
|
||||
string__append_list(["expected predname/arity for `pragma ",
|
||||
PragmaType, "(...)' declaration"], ErrorMsg),
|
||||
Result = error(ErrorMsg, PredAndArityTerm)
|
||||
).
|
||||
|
||||
%-----------------------------------------------------------------------------%
|
||||
|
||||
:- pred parse_pragma_keyword(string, term, string, term__context).
|
||||
|
||||
Reference in New Issue
Block a user