hpfc.h File Reference

#include "hpf_private.h"
#include "hpf.h"
#include "message.h"

Include dependency graph for hpfc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	HPFC_PACKAGE   "HPFC-PACKAGE"
	Warning! Do not modify this file that is automatically generated! More...

Functions
bool	the_dynamics_undefined_p (void)
	end of it More...
void	reset_the_dynamics (void)
void	error_reset_the_dynamics (void)
void	set_the_dynamics (list)
list	get_the_dynamics (void)
void	init_the_dynamics (void)
void	close_the_dynamics (void)
void	add_a_dynamic (entity)
	local primary dynamics More...
void	hpfc_directives_error_handler (void)
	the local stack is used to retrieve the current statement while scanning the AST with gen_recurse. More...
void	handle_hpf_directives (statement, bool)
	void handle_hpf_directives(s) statement s; More...
bool	dynamic_hpf_undefined_p (void)
	dynamic.c More...
void	reset_dynamic_hpf (void)
void	error_reset_dynamic_hpf (void)
void	set_dynamic_hpf (entity_entities)
entity_entities	get_dynamic_hpf (void)
void	init_dynamic_hpf (void)
void	close_dynamic_hpf (void)
void	store_dynamic_hpf (entity, entities)
void	update_dynamic_hpf (entity, entities)
entities	load_dynamic_hpf (entity)
entities	delete_dynamic_hpf (entity)
bool	bound_dynamic_hpf_p (entity)
void	store_or_update_dynamic_hpf (entity, entities)
bool	primary_entity_undefined_p (void)
void	reset_primary_entity (void)
void	error_reset_primary_entity (void)
void	set_primary_entity (entitymap)
entitymap	get_primary_entity (void)
void	init_primary_entity (void)
void	close_primary_entity (void)
void	store_primary_entity (entity, entity)
void	update_primary_entity (entity, entity)
entity	load_primary_entity (entity)
entity	delete_primary_entity (entity)
bool	bound_primary_entity_p (entity)
void	store_or_update_primary_entity (entity, entity)
bool	renamings_undefined_p (void)
void	reset_renamings (void)
void	error_reset_renamings (void)
void	set_renamings (statement_renamings)
statement_renamings	get_renamings (void)
void	init_renamings (void)
void	close_renamings (void)
void	store_renamings (statement, list)
void	update_renamings (statement, list)
list	load_renamings (statement)
list	delete_renamings (statement)
bool	bound_renamings_p (statement)
void	store_or_update_renamings (statement, list)
bool	maybeuseful_mappings_undefined_p (void)
void	reset_maybeuseful_mappings (void)
void	error_reset_maybeuseful_mappings (void)
void	set_maybeuseful_mappings (statement_entities)
statement_entities	get_maybeuseful_mappings (void)
void	init_maybeuseful_mappings (void)
void	close_maybeuseful_mappings (void)
void	store_maybeuseful_mappings (statement, entities)
void	update_maybeuseful_mappings (statement, entities)
entities	load_maybeuseful_mappings (statement)
entities	delete_maybeuseful_mappings (statement)
bool	bound_maybeuseful_mappings_p (statement)
void	store_or_update_maybeuseful_mappings (statement, entities)
bool	similar_mapping_undefined_p (void)
void	reset_similar_mapping (void)
void	error_reset_similar_mapping (void)
void	set_similar_mapping (entitymap)
entitymap	get_similar_mapping (void)
void	init_similar_mapping (void)
void	close_similar_mapping (void)
void	store_similar_mapping (entity, entity)
void	update_similar_mapping (entity, entity)
entity	load_similar_mapping (entity)
entity	delete_similar_mapping (entity)
bool	bound_similar_mapping_p (entity)
void	store_or_update_similar_mapping (entity, entity)
entity	safe_load_primary_entity (entity)
	HPFC module by Fabien COELHO. More...
bool	same_primary_entity_p (entity, entity)
void	init_dynamic_status (void)
	DYNAMIC STATUS management. More...
void	reset_dynamic_status (void)
dynamic_status	get_dynamic_status (void)
void	set_dynamic_status (dynamic_status)
void	close_dynamic_status (void)
void	set_entity_as_dynamic (entity)
	a new dynamic entity is stored. More...
void	set_similar_mappings_for_updates (void)
void	hpfc_check_for_similarities (list)
	check all dynamic arrays for some similars... More...
bool	conformant_templates_p (entity, entity)
entity	array_synonym_aligned_as (entity, align)
	entity array_synonym_aligned_as(array, a) entity array; align a; More...
align	new_align_with_template (align, entity)
entity	template_synonym_distributed_as (entity, distribute)
	what: finds or creates a new entity distributed as needed. More...
bool	array_distribution_similar_p (entity, entity)
bool	hpfc_call_with_distributed_args_p (call)
	whether call c inplies a distributed argument More...
void	hpfc_translate_call_with_distributed_args (statement, call)
	??? only simple calls are handled. More...
void	init_dynamic_locals (void)
	DYNAMIC LOCAL DATA. More...
void	close_dynamic_locals (void)
void	add_as_a_used_dynamic_to_statement (statement, entity)
void	propagate_synonym (statement, entity, entity, bool)
void	dump_current_remapping_graph (string)
void	simplify_remapping_graph (void)
	void simplify_remapping_graph() More...
list	alive_arrays (statement, entity)
	what: returns the list of alive arrays for statement s and template t. More...
statement	generate_copy_loop_nest (entity, entity)
	statement generate_copy_loop_nest(src, trg) entity src, trg; More...
bool	hpf_reductions_undefined_p (void)
	hpfc.c More...
void	reset_hpf_reductions (void)
void	error_reset_hpf_reductions (void)
void	set_hpf_reductions (statement_entities)
statement_entities	get_hpf_reductions (void)
void	init_hpf_reductions (void)
void	close_hpf_reductions (void)
void	store_hpf_reductions (statement, entities)
void	update_hpf_reductions (statement, entities)
entities	load_hpf_reductions (statement)
entities	delete_hpf_reductions (statement)
bool	bound_hpf_reductions_p (statement)
void	store_or_update_hpf_reductions (statement, entities)
void	add_a_common (entity)
	HPFC module by Fabien COELHO. More...
void	add_a_pure (entity)
bool	hpf_pure_p (entity)
	??? some intrinsics should also be considered as pure. More...
void	add_an_io_function (entity)
bool	hpfc_special_io (entity)
void	add_a_fake_function (entity)
bool	hpfc_special_fake (entity)
bool	remapping_already_computed_p (renaming)
	list of already computed remappings... More...
void	add_remapping_as_computed (renaming, list)
	variables to be declared More...
void	add_remapping_as_used (renaming)
void	hpfc_add_ahead_of_node_code (statement)
bool	hpfc_init (const string)
	bool hpfc_init(string name) More...
bool	hpfc_filter (const string)
bool	hpfc_static_directives (const string)
bool	hpfc_dynamic_directives (const string)
bool	hpfc_compile (const string)
	bool hpfc_compile(string name) More...
bool	hpfc_common (const string)
	bool hpfc_common(string name) More...
bool	hpfc_close (const string)
	bool hpfc_close(string name) More...
bool	hpfc_install (const string)
	bool hpfc_install(string name) More...
bool	hpfc_make (const string)
	bool hpfc_make(string name) More...
bool	hpfc_run (const string)
	bool hpfc_run(string name) More...
void	print_align (align)
	debug-util.c More...
void	print_alignment (alignment)
void	print_aligns (void)
void	print_distributes (void)
void	print_distribute (distribute)
void	print_distribution (distribution)
void	print_hpf_dir (void)
void	print_templates (void)
void	print_processors (void)
void	print_distributed_arrays (void)
void	hpfc_print_common (FILE *, entity, entity)
void	hpfc_print_file (string)
void	fprint_range (FILE *, range)
void	fprint_lrange (FILE *, list)
void	fprint_message (FILE *, message)
void	fprint_lmessage (FILE *, list)
bool	ref_to_dist_array_p (void *)
	hpfc-util.c More...
bool	written_effect_p (entity, list)
	written_effects_to_dist_arrays_p More...
bool	written_effects_to_dist_arrays_p (expression)
bool	replicated_p (entity)
	replicated_p More...
bool	ith_dim_replicated_p (entity, int, list, distribution)
bool	processors_dim_replicated_p (entity, entity, int)
bool	ith_dim_distributed_p (entity, int, int *)
	whether a dimension is distributed or not. More...
bool	ith_dim_overlapable_p (entity, int)
statement	MakeStatementLike (statement, int)
	creates a new statement for the given module that looks like the stat one, i.e. More...
void	kill_statement_number_and_ordering (statement)
list	DistArraysEffects (expression)
	effects' action in an expression are here supposed to be read one's but that may not be correct? More...
list	FindRefToDistArrayFromList (list)
	FindRefToDistArrayFromList. More...
list	FindRefToDistArray (void *)
void	AddEntityToHostAndNodeModules (entity)
	AddEntityToHostAndNodeModules. More...
void	AddCommonToModule (entity, entity, void(*)(void), string)
void	AddCommonToHostAndNodeModules (entity)
alignment	FindAlignmentOfDim (list, int)
alignment	FindAlignmentOfTemplateDim (list, int)
distribution	FindDistributionOfDim (list, int, int *)
distribution	FindDistributionOfProcessorDim (list, int, int *)
int	template_dimension_of_array_dimension (entity, int)
int	processor_dimension_of_template_dimension (entity, int)
int	DistributionParameterOfArrayDim (entity, int, int *)
int	processor_number (entity, int, int, int *)
	int processor_number(template, tdim, tcell, pprocdim) More...
int	template_cell_local_mapping (entity, int, int)
	int template_cell_local_mapping(array, dim, tc) More...
int	global_array_cell_to_local_array_cell (entity, int, int)
	int global_array_cell_to_local_array_cell(array, dim, acell) More...
int	HpfcExpressionToInt (expression)
	HpfcExpressionToInt(e) More...
void	get_alignment (entity, int, int *, int *, int *)
void	get_distribution (entity, int, int *, int *)
void	get_entity_dimensions (entity, int, int *, int *)
bool	alignments_compatible_p (entity, int, entity, int)
	bool alignments_compatible_p(entity e1, int dim1, entity e2, int dim2) More...
bool	references_aligned_p (reference, reference)
void	hpfc_util_error_handler (void)
	removes IF (.TRUE.) THEN and DO X=n, n More...
void	statement_structural_cleaning (statement)
int	number_of_distributed_arrays (void)
	declarations.c More...
list	list_of_distributed_arrays (void)
bool	array_distributed_p (entity)
void	set_array_as_distributed (entity)
bool	declaration_delayed_p (entity)
list	list_of_distributed_arrays_for_module (entity)
	returns the list of entities that are 'local' to module More...
int	number_of_templates (void)
list	list_of_templates (void)
bool	entity_template_p (entity)
void	set_template (entity)
int	number_of_processors (void)
list	list_of_processors (void)
bool	entity_processor_p (entity)
void	set_processor (entity)
void	reset_hpf_object_lists (void)
void	free_hpf_object_lists (void)
bool	hpf_number_undefined_p (void)
void	reset_hpf_number (void)
void	error_reset_hpf_number (void)
void	set_hpf_number (entity_int)
entity_int	get_hpf_number (void)
void	init_hpf_number (void)
void	close_hpf_number (void)
void	store_hpf_number (entity, intptr_t)
void	update_hpf_number (entity, intptr_t)
intptr_t	load_hpf_number (entity)
intptr_t	delete_hpf_number (entity)
bool	bound_hpf_number_p (entity)
void	store_or_update_hpf_number (entity, intptr_t)
void	init_hpf_number_status (void)
	STANDARS STATIC MANAGEMENT. More...
numbers_status	get_hpf_number_status (void)
void	reset_hpf_number_status (void)
void	set_hpf_number_status (numbers_status)
void	close_hpf_number_status (void)
void	GiveToHpfObjectsTheirNumber (void)
	give to hpf objects listed in distributedarrays, templates and processors their number for the code generation... More...
expression	entity_hpf_number (entity)
	returns the hpf_number parameter as a string not really needed ??? ??? never called More...
bool	hpf_alignment_undefined_p (void)
void	reset_hpf_alignment (void)
void	error_reset_hpf_alignment (void)
void	set_hpf_alignment (alignmap)
alignmap	get_hpf_alignment (void)
void	init_hpf_alignment (void)
void	close_hpf_alignment (void)
void	store_hpf_alignment (entity, align)
void	update_hpf_alignment (entity, align)
align	load_hpf_alignment (entity)
align	delete_hpf_alignment (entity)
bool	bound_hpf_alignment_p (entity)
void	store_or_update_hpf_alignment (entity, align)
bool	hpf_distribution_undefined_p (void)
void	reset_hpf_distribution (void)
void	error_reset_hpf_distribution (void)
void	set_hpf_distribution (distributemap)
distributemap	get_hpf_distribution (void)
void	init_hpf_distribution (void)
void	close_hpf_distribution (void)
void	store_hpf_distribution (entity, distribute)
void	update_hpf_distribution (entity, distribute)
distribute	load_hpf_distribution (entity)
distribute	delete_hpf_distribution (entity)
bool	bound_hpf_distribution_p (entity)
void	store_or_update_hpf_distribution (entity, distribute)
tag	new_declaration_tag (entity, int)
void	get_ith_dim_new_declaration (entity, int, int *, int *)
void	init_data_status (void)
data_status	get_data_status (void)
void	reset_data_status (void)
void	set_data_status (data_status)
void	close_data_status (void)
void	normalize_distribute (entity, distribute)
void	normalize_align (entity, align)
void	normalize_hpf_object (entity)
void	NormalizeHpfDeclarations (void)
void	NewDeclarationsOfDistributedArrays (void)
	this procedure generate the new declarations of every distributed arrays of the program, in order to minimize the amount of memory used. More...
bool	overlap_status_undefined_p (void)
void	reset_overlap_status (void)
void	error_reset_overlap_status (void)
void	set_overlap_status (overlapsmap)
overlapsmap	get_overlap_status (void)
void	init_overlap_status (void)
void	close_overlap_status (void)
void	store_overlap_status (entity, list)
void	update_overlap_status (entity, list)
list	load_overlap_status (entity)
list	delete_overlap_status (entity)
bool	bound_overlap_status_p (entity)
void	store_or_update_overlap_status (entity, list)
void	set_overlap (entity, int, int, int)
	set the overlap value for entity ent, on dimension dim, dans side side to width, which must be a positive integer. More...
int	get_overlap (entity, int, int)
	returns the overlap for a given entity, dimension and side, to be used in the declaration modifications More...
void	declaration_with_overlaps_for_module (entity)
void	update_overlaps_in_caller (entity, list)
	the overlaps of the actual parameters are updated according to the formal requirements. More...
void	update_control_lists (control, control_mapping)
	compiler-util.c More...
list	updated_control_list (list, control_mapping)
void	FindRefToDistArrayInStatement (statement, list *, list *)
list	lIndicesOfRef (list)
	computes the list of indices of the list of ref that are variables... More...
list	IndicesOfRef (syntax)
list	AddOnceToIndicesList (list, list)
bool	is_in_syntax_list (entity, list)
list	FindDefinitionsOf (statement, list)
bool	atomic_accesses_only_p (statement)
bool	indirections_inside_statement_p (statement)
statement	parallel_loop_nest_to_body (statement, list *, list *)
void	set_current_loops (statement)
void	reset_current_loops (void)
bool	entity_loop_index_p (entity)
range	loop_index_to_range (entity)
void	hpf_compiler (statement, statement *, statement *)
	what: compile a statement into a host and SPMD node code. More...
void	make_host_and_node_modules (entity)
	compile.c More...
void	init_host_and_node_entities (void)
	both host and node modules are initialized with the same declarations than the compiled module, but the distributed arrays declarations... More...
FILE *	hpfc_fopen (string)
void	hpfc_fclose (FILE *, string)
void	hpfc_print_code (FILE *, entity, statement)
void	put_generated_resources_for_common (entity)
void	compile_a_special_io_function (entity)
	just copied for the host More...
void	compile_a_pure_function (entity)
	simply copied for both host and node... More...
void	put_generated_resources_for_module (statement, statement, statement)
void	put_generated_resources_for_program (string)
void	hpfcompile (const char *)
	Compiler call, obsole. More...
entity	hpfc_new_variable (entity, basic)
void	hpfc_compile_error_handler (void)
void	NormalizeCodeForHpfc (statement)
bool	update_common_map_undefined_p (void)
void	set_update_common_map (entity_mapping)
entity_mapping	get_update_common_map (void)
void	reset_update_common_map (void)
void	free_update_common_map (void)
void	make_update_common_map (void)
entity	load_entity_update_common (entity)
void	delete_entity_update_common (entity)
bool	entity_update_common_undefined_p (entity)
void	store_entity_update_common (entity, entity)
void	update_entity_update_common (entity, entity)
void	debug_print_referenced_entities (void *)
void	update_common_references_in_obj (void *)
void	update_common_references_in_regions (void)
void	NormalizeCommonVariables (entity, statement)
entity	MakeRunTimeSupportSubroutine (string, int)
	run-time.c More...
entity	MakeRunTimeSupportFunction (string, int, tag)
expression	pvm_what_option_expression (entity)
string	pvm_what_options (basic)
	string pvm_what_options(b) More...
statement	st_call_send_or_receive (entity, reference)
	Sends. More...
statement	st_compute_current_computer (reference)
	Computes. More...
statement	st_compute_current_owners (reference)
expression	expr_compute_local_index (entity, int, expression)
	new index computation formula, derived from the new declarations made for the given dimension. More...
statement	hpfc_make_call_statement (entity, list)
	statement hpfc_make_call_statement(e, l) generate a call statement to function e, with expression list l as an argument. More...
void	add_pvm_init_and_end (statement *, statement *)
	this is for the main. More...
statement	st_compute_neighbour (int)
	call to the runtime support function HPFC_CMPNEIGHBOUR(d) More...
statement	st_generate_packing (entity, list, bool)
	statement st_generate_packing_and_passing(array, content, bsend) More...
entity	hpfc_main_entity (entity)
	returns the entity to which e is attached, that is first a common, then a function... More...
const char *	hpfc_main_entity_name (entity)
	returns the name of the entity e belongs too (common, function...) More...
string	bound_parameter_name (entity, string, int)
	returns a name for the bound of the declaration of array array, side side and dimension dim. More...
entity	argument_bound_entity (entity, entity, bool, int)
expression	hpfc_array_bound (entity, bool, int)
list	array_lower_upper_bounds_list (entity)
	of expressions More...
void	hpfc_init_run_time_entities (void)
	to be seen from outside of this file More...
entity	hpfc_name_to_entity (const char *)
bool	hpfc_intrinsic_like_function (entity)
bool	hpfc_io_like_function (entity)
void	generate_c1_beta (statement, list *, list *)
	generate.c More...
void	generate_c1_alpha (statement, list *, list *)
	generate_c1_alpha More...
void	generate_update_values_on_nodes (reference, reference, list *, list *)
	generate_update_values_on_nodes More...
void	generate_read_of_ref_for_computer (syntax, list *, list *)
	generate_read_of_ref_for_computer More...
void	generate_read_of_ref_for_all (syntax, list *, list *)
	generate_read_of_ref_for_all More...
void	generate_compute_local_indices (reference, list *, list *)
	generate_compute_local_indices More...
void	generate_get_value_locally (reference, reference, list *)
	generate_get_value_locally More...
void	generate_send_to_computer (reference, list *)
	generate_send_to_computer More...
void	generate_receive_from_computer (reference, list *)
void	generate_parallel_body (statement, list *, list, list)
void	generate_update_values_on_computer_and_nodes (reference, reference, list *, list *)
	generate_update_values_on_computer_and_nodes More...
void	generate_update_distributed_value_from_host (syntax, list *, list *)
	generate_update_distributed_value_from_host More...
void	generate_update_private_value_from_host (syntax, list *, list *)
	generate_update_private_value_from_host More...
statement	st_get_value_locally_and_send (reference, reference)
statement	st_compute_ith_local_index (entity, int, expression, syntax *)
	the returned expression is translated into variables of the node module. More...
statement	st_send_to_host_and_nodes (reference, reference)
statement	st_send_to_computer_if_necessary (reference)
statement	st_get_value_for_all (reference, reference)
statement	st_get_value_for_computer (reference, reference)
statement	st_receive_from (reference, reference)
	if ref is replicated: goal = Receive_From_Sender() More...
type	type_variable_dup (type)
	local-ri-util.c More...
bool	fortran_library_entity_p (entity)
void	create_common_parameters_h (FILE *)
	inits.c More...
void	create_parameters_h (FILE *, entity)
	create_parameters_h More...
int	max_size_of_processors (void)
void	create_init_common_param_for_arrays (FILE *, entity)
void	create_init_common_param_for_templates (FILE *)
void	create_init_common_param_for_processors (FILE *)
void	create_init_common_param (FILE *)
	create_init_common_param (templates and modules) More...
bool	block_distributed_p (entity)
	o-analysis.c More...
bool	Overlap_Analysis (statement, statement *)
	check conditions and compile... More...
bool	hpfc_current_statement_undefined_p (void)
	align-checker.c More...
void	reset_hpfc_current_statement (void)
void	error_reset_hpfc_current_statement (void)
void	set_hpfc_current_statement (statement)
statement	get_hpfc_current_statement (void)
bool	local_integer_constant_expression (expression)
	true is the expression is locally constant, that is in the whole loop nest, the reference is not written. More...
bool	align_check (reference, reference, list *, list *)
	computes the shift vector that links the two references, true if every thing is ok, i.e. More...
bool	hpfc_integer_constant_expression_p (expression, int *)
statement	messages_handling (list, list)
	messages.c More...
Pvecteur	the_index_of_vect (Pvecteur)
	message-utils.c More...
list	add_to_list_of_ranges_list (list, range)
list	dup_list_of_ranges_list (list)
	??? the complexity of this function could be greatly improved More...
list	dup_list_of_Pvecteur (list)
	??? the complexity of this function could be improved greatly... More...
list	add_elem_to_list_of_Pvecteur (list, int, int)
	caution, is initial list is destroyed. More...
range	complementary_range (entity, int, range)
	range complementary_range(array, dim, r) More...
list	generate_message_from_3_lists (entity, list, list, list)
	list generate_message_from_3_lists(array, lcontent, lneighbour, ldomain) More...
bool	empty_section_p (list)
bool	empty_range_p (range)
char *	sprint_lrange (string, list)
char *	sprint_range (string, range)
list	compute_receive_content (entity, list, Pvecteur)
list	compute_receive_domain (list, Pvecteur)
bool	larger_message_in_list (message, list)
bool	message_larger_p (message, message)
	bool message_larger_p(m1, m2) More...
bool	lrange_larger_p (list, list)
list	array_ranges_to_template_ranges (entity, list)
list	template_ranges_to_processors_ranges (entity, list)
list	array_access_to_array_ranges (reference, list, list)
statement	generate_guarded_statement (statement, entity, list)
bool	make_guard_expression (entity, list, expression *)
	bool make_guard_expression(proc, lr, pguard) More...
expression	make_mypos_expression (int, expression)
statement	loop_nest_guard (statement, reference, list, list)
bool	entity_hpfc_dummy_p (entity)
	build-system.c More...
entity	get_ith_region_dummy (int)
entity	get_ith_region_prime (int)
entity	get_ith_array_dummy (int)
entity	get_ith_array_prime (int)
entity	get_ith_template_dummy (int)
entity	get_ith_template_prime (int)
entity	get_ith_processor_dummy (int)
entity	get_ith_processor_prime (int)
entity	get_ith_block_dummy (int)
entity	get_ith_block_prime (int)
entity	get_ith_cycle_dummy (int)
entity	get_ith_cycle_prime (int)
entity	get_ith_local_dummy (int)
entity	get_ith_local_prime (int)
entity	get_ith_shift_dummy (int)
entity	get_ith_shift_prime (int)
entity	get_ith_auxiliary_dummy (int)
entity	get_ith_auxiliary_prime (int)
entity	get_ith_temporary_dummy (int)
entity	get_ith_temporary_prime (int)
void	hpfc_init_dummy_to_prime (void)
void	hpfc_close_dummy_to_prime (void)
Psysteme	shift_system_to_prime_variables (Psysteme)
void	make_hpfc_current_mappings (void)
	??? used with a temporary hack to differentiate array and templates More...
void	free_hpfc_current_mappings (void)
Psysteme	compute_entity_to_declaration_constraints (entity, string, string)
	Psysteme compute_entity_to_constraints(ent, suffix, prefix) entity ent: variable the constraints of which are computed strings suffix and prefix: to be used in the dummy variables created. More...
Psysteme	entity_to_declaration_constraints (entity, tag)
	gives back the constraints due to the declarations. More...
Psysteme	hpfc_compute_unicity_constraints (entity)
	Psysteme hpfc_compute_unicity_constraints(e) entity e should be an array;. More...
Psysteme	entity_to_hpf_align_constraints (entity)
Psysteme	entity_to_hpf_distribute_constraints (entity)
effect	entity_to_region (statement, entity, tag)
	effect entity_to_region(stat, ent, act) statement stat; entity ent; tag act; More...
Psysteme	hpfc_compute_entity_to_new_declaration (entity)
Psysteme	entity_to_new_declaration (entity)
Psysteme	generate_system_for_equal_variables (int, entity(*)(int), entity(*)(int))
Psysteme	hpfc_unstutter_dummies (entity)
Psysteme	generate_system_for_distributed_variable (entity)
	Psysteme generate_system_for_variable(v) entity v;. More...
bool	only_io_map_undefined_p (void)
	io-util.c More...
void	set_only_io_map (statement_mapping)
statement_mapping	get_only_io_map (void)
void	reset_only_io_map (void)
void	free_only_io_map (void)
void	make_only_io_map (void)
bool	load_statement_only_io (statement)
void	delete_statement_only_io (statement)
bool	statement_only_io_undefined_p (statement)
void	store_statement_only_io (statement, bool)
void	update_statement_only_io (statement, bool)
void	hpfc_io_util_error_handler (void)
	??? neglect expression side effects... More...
void	only_io_mapping_initialize (statement)
void	generate_io_statements_for_distributed_arrays (entity, tag, Psysteme, Psysteme, Psysteme, list, list, list, list, statement *, statement *)
void	generate_io_statements_for_shared_arrays (entity, tag, Psysteme, Psysteme, list, list, list, statement *, statement *)
void	hpfc_algorithm_row_echelon (Psysteme, list, Psysteme *, Psysteme *)
	io-compile.c More...
list	make_list_of_dummy_variables (entity(*)(void), int)
void	remove_variables_if_possible (Psysteme *, list *)
void	remove_variables_from_system (Psysteme *, list *)
void	clean_the_system (Psysteme *, list *, list *)
list	simplify_deducable_variables (Psysteme, list, list *)
	list simplify_deducable_variables(syst, vars, pleftvars) Psysteme syst; list vars, *pleftvars; More...
list	hpfc_order_variables (list, bool)
	list hpfc_order_variables(list) More...
void	hpfc_algorithm_tiling (Psysteme, list, list, Psysteme *, Psysteme *, Psysteme *)
void	hpfc_simplify_condition (Psysteme *, statement, tag)
	void hpfc_simplify_condition(psc, stat, move) More...
void	io_efficient_compile (statement, statement *, statement *)
	compile an io statement More...
statement	define_node_processor_id (entity, entity(*)(int))
	generate-util.c More...
statement	generate_deducables (list)
	statement generate_deducables(list le) More...
list	hpfc_gen_n_vars_expr (entity(*)(void), int)
expression	make_reference_expression (entity, entity(*)(void))
statement	hpfc_add_n (entity, int)
	returns statement VAR = VAR + N More...
statement	hpfc_add_2 (expression)
	expr = expr + 2 More...
statement	hpfc_message (expression, expression, bool)
statement	hpfc_lazy_guard (bool, statement)
	returns if (LAZY_{SEND,RECV}) then More...
statement	hpfc_generate_message (entity, bool, bool)
statement	hpfc_initsend (bool)
expression	hpfc_buffer_reference (entity, entity)
	returns a reference to the typed common hpfc_buffer buffer, that suits array basic type and with index as an index. More...
statement	hpfc_buffer_packing (entity, entity(*)(void), bool)
statement	hpfc_packing_of_current__buffer (entity, bool)
	CALL (pvmtype) HPFC {,UN}PACK. More...
statement	hpfc_broadcast_if_necessary (entity, entity, entity, entity, bool)
	lazy or not... More...
statement	hpfc_lazy_buffer_packing (entity, entity, entity, entity, entity(*)(void), bool, bool)
statement	hpfc_buffer_initialization (bool, bool, bool)
statement	hpfc_lazy_packing (entity, entity, entity(*)(void), bool, bool)
statement	hpfc_compute_lid (entity, entity, entity(*)(void), entity)
Pcontrainte	full_linearization (entity, entity, int *, entity(*)(int), bool, int)
	remapping.c More...
statement	generate_all_liveness (entity, bool)
statement	root_statement_remapping_inits (statement)
	returns the initialization statement: must initialize the status and liveness of arrays More...
void	remapping_compile (statement, statement *, statement *)
	void remapping_compile(s, hsp, nsp) statement s, *hsp, *nsp; More...
bool	new_host_undefined_p (void)
	host_node_entities.c More...
void	reset_new_host (void)
void	error_reset_new_host (void)
void	set_new_host (entitymap)
entitymap	get_new_host (void)
void	init_new_host (void)
void	close_new_host (void)
void	store_new_host (entity, entity)
void	update_new_host (entity, entity)
entity	load_new_host (entity)
entity	delete_new_host (entity)
bool	bound_new_host_p (entity)
void	store_or_update_new_host (entity, entity)
bool	old_host_undefined_p (void)
void	reset_old_host (void)
void	error_reset_old_host (void)
void	set_old_host (entitymap)
entitymap	get_old_host (void)
void	init_old_host (void)
void	close_old_host (void)
void	store_old_host (entity, entity)
void	update_old_host (entity, entity)
entity	load_old_host (entity)
entity	delete_old_host (entity)
bool	bound_old_host_p (entity)
void	store_or_update_old_host (entity, entity)
bool	new_node_undefined_p (void)
void	reset_new_node (void)
void	error_reset_new_node (void)
void	set_new_node (entitymap)
entitymap	get_new_node (void)
void	init_new_node (void)
void	close_new_node (void)
void	store_new_node (entity, entity)
void	update_new_node (entity, entity)
entity	load_new_node (entity)
entity	delete_new_node (entity)
bool	bound_new_node_p (entity)
void	store_or_update_new_node (entity, entity)
bool	old_node_undefined_p (void)
void	reset_old_node (void)
void	error_reset_old_node (void)
void	set_old_node (entitymap)
entitymap	get_old_node (void)
void	init_old_node (void)
void	close_old_node (void)
void	store_old_node (entity, entity)
void	update_old_node (entity, entity)
entity	load_old_node (entity)
entity	delete_old_node (entity)
bool	bound_old_node_p (entity)
void	store_or_update_old_node (entity, entity)
void	debug_host_node_variables (entity)
	HPFC module by Fabien COELHO. More...
void	store_new_node_variable (entity, entity)
void	store_new_host_variable (entity, entity)
void	store_new_host_node_variable (entity, entity, entity)
void	init_entity_status (void)
entity_status	get_entity_status (void)
void	set_entity_status (entity_status)
void	reset_entity_status (void)
void	close_entity_status (void)
string	hpfc_module_suffix (entity)
void	update_object_for_module (void *, entity)
void	update_list_for_module (list, entity)
expression	UpdateExpressionForModule (entity, expression)
	this function creates a new expression using the mapping of old to new variables map. More...
list	lUpdateExpr_but_distributed (entity, list)
	used for compiling calls. More...
list	lUpdateExpr (entity, list)
list	lNewVariableForModule (entity, list)
entity	NewVariableForModule (entity, entity)
statement	UpdateStatementForModule (entity, statement)
bool	hpfc_entity_reduction_p (entity)
	special_cases.c More...
bool	call_reduction_p (call)
bool	compile_reduction (statement, statement *, statement *)
	bool compile_reduction(initial, phost, pnode) More...
list	handle_hpf_reduction (statement)
	of hpfc_reductions More...
list	compile_hpf_reduction (list, bool, bool)
	of statement More...
void	free_vector_list (list)
bool	subarray_shift_p (statement, entity *, list *)
Psysteme	get_read_effect_area (list, entity)
list	make_rectangular_area (statement, entity)
statement	generate_subarray_shift (statement, entity, list)
	statement generate_subarray_shift(s, var, lshift) statement s; entity var; list lshift; More...
void	hpfc_special_cases_error_handler (void)
statement	simple_statement (statement)
bool	full_define_p (reference, list)
bool	full_copy_p (statement, reference *, reference *)
statement	generate_full_copy (reference, reference)
	statement generate_full_copy(reference left, reference right) More...
void	extract_lattice (Psysteme, list, list *, list *)
	lattice_extraction.c More...

Variables
bool(*	dynamic_entity_p )(entity)
	as expected, true if entity e is dynamic. More...
entity	host_module
	compiler.c More...
entity	node_module

Macro Definition Documentation

HPFC_PACKAGE

#define HPFC_PACKAGE   "HPFC-PACKAGE"

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/hpfc/hpfc-local.h instead, to add your own modifications. header file built by cproto hpfc-local.h local definitions

Definition at line 35 of file hpfc.h.

Function Documentation

add_a_common()

void add_a_common

(

entity

c

)

HPFC module by Fabien COELHO.

Definition at line 48 of file hpfc.c.

{ the_commons_object = gen_once(c, the_commons_object);}

References gen_once().

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_a_dynamic()

void add_a_dynamic

(

entity

c

)

local primary dynamics

Definition at line 99 of file directives.c.

{
  the_dynamics_object = gen_once(c, the_dynamics_object);
}

References gen_once().

Referenced by hpfc_translate_call_with_distributed_args(), and new_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

add_a_fake_function()

void add_a_fake_function

(

entity

f

)

Definition at line 88 of file hpfc.c.

{ the_fakes_object = gen_once(f, the_fakes_object);}

References f(), gen_once(), and the_fakes_object.

Referenced by handle_fake_directive(), and new_fake_function().

Here is the call graph for this function:

Here is the caller graph for this function:

add_a_pure()

void add_a_pure

(

entity

f

)

Definition at line 62 of file hpfc.c.

{ the_pures_object = gen_once(f, the_pures_object);}

References f(), and gen_once().

Referenced by handle_pure_directive(), and new_pure_function().

Here is the call graph for this function:

Here is the caller graph for this function:

add_an_io_function()

void add_an_io_function

(

entity

f

)

Definition at line 74 of file hpfc.c.

{ the_ios_object = gen_once(f, the_ios_object);}

References f(), and gen_once().

Referenced by handle_io_directive(), and new_io_function().

Here is the call graph for this function:

Here is the caller graph for this function:

add_as_a_used_dynamic_to_statement()

void add_as_a_used_dynamic_to_statement	(	statement	s,
		entity	e
	)

Definition at line 904 of file dynamic.c.

{
    entities es = load_used_dynamics(s);
    entities_list(es) = gen_once(load_primary_entity(e), entities_list(es));
}

References entities_list, gen_once(), and load_primary_entity().

Referenced by initial_alignment().

Here is the call graph for this function:

Here is the caller graph for this function:

add_elem_to_list_of_Pvecteur()

list add_elem_to_list_of_Pvecteur	(	list	l,
		int	var,
		int	val
	)

caution, is initial list is destroyed.

else

Parameters

var	ar
val	al

Definition at line 110 of file message-utils.c.

{
    list result = NIL;
 
    if (ENDP(l))
        return CONS(PVECTOR, (VECTOR) vect_new((Variable) (intptr_t)var,
                                               int_to_value(val)), NIL);
 
    if ((var==0) || (val==0))
        return l;
 
    /* else */
 
    MAPL(cv,
     {
         Pvecteur v = (Pvecteur) PVECTOR(CAR(cv));
         pips_debug(9, "size of vector %p is %d\n", v, vect_size(v));
         vect_add_elem(&v, (Variable) (intptr_t) var, int_to_value(val));
         result = gen_nconc(result, CONS(PVECTOR, (VECTOR) v, NIL));
     },
         l);
 
    gen_free_list(l);
 
    return result;
}

References CAR, CONS, ENDP, gen_free_list(), gen_nconc(), int_to_value, intptr_t, MAPL, NIL, pips_debug, PVECTOR, vect_add_elem(), vect_new(), vect_size(), and VECTOR.

Referenced by atomize_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

add_pvm_init_and_end()

void add_pvm_init_and_end	(	statement *	phs,
		statement *	pns
	)

this is for the main.

also subs CALL RETURN -> CALL HPFC {HOST|NONE} END...

Parameters

phs	hs
pns	ns

Definition at line 364 of file run-time.c.

{
    entity
        rete = entity_intrinsic("RETURN"),
        hhe = hpfc_name_to_entity(HOST_END),
        hne = hpfc_name_to_entity(NODE_END);
    statement ret = hpfc_make_call_statement(rete, NIL);
 
    substitute_return(rete, hhe, *phs);
    substitute_return(rete, hne, *pns);
 
 
    if (sub_ret_label!=entity_undefined) {
        statement_label(ret) = sub_ret_label;
        sub_ret_label = entity_undefined;
    }
 
    (*phs) = make_block_statement(CONS(STATEMENT, st_init_host(),
                                  CONS(STATEMENT, (*phs),
                                  CONS(STATEMENT, ret,
                                       NIL))));
 
    (*pns) = make_block_statement(CONS(STATEMENT, st_init_node(),
                                  CONS(STATEMENT, (*pns),
                                  CONS(STATEMENT, copy_statement(ret),
                                       NIL))));
}

References CONS, copy_statement(), entity_intrinsic(), entity_undefined, HOST_END, hpfc_make_call_statement(), hpfc_name_to_entity(), make_block_statement(), NIL, NODE_END, ret, st_init_host, st_init_node, STATEMENT, statement_label, sub_ret_label, and substitute_return().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

add_remapping_as_computed()

void add_remapping_as_computed	(	renaming	r,
		list	vars
	)

variables to be declared

Parameters

vars

ars

Definition at line 121 of file hpfc.c.

{
    computed_remaps_object = CONS(REMAPPING, 
        make_remapping(copy_renaming(r), gen_copy_seq(vars)),
                           computed_remaps_object);
}

References CONS, copy_renaming(), gen_copy_seq(), make_remapping(), and REMAPPING.

Referenced by generate_hpf_remapping_file().

Here is the call graph for this function:

Here is the caller graph for this function:

add_remapping_as_used()

void add_remapping_as_used

(

renaming

x

)

Definition at line 135 of file hpfc.c.

{
    entity src = renaming_old(x), trg = renaming_new(x);
    remapping p = remapping_undefined;
 
    MAP(REMAPPING, r, 
    {
        renaming y = remapping_renaming(r);
 
        if (renaming_old(y)==src && renaming_new(y)==trg) 
        {
            p = r;
            break;
        }
    },
        get_computed_remaps());
 
    pips_assert("defined remapping", !remapping_undefined_p(p));
 
    MAP(ENTITY, e, 
        include_entities_object = gen_once(e, include_entities_object), 
        remapping_referenced(p));
}

References ENTITY, gen_once(), MAP, pips_assert, REMAPPING, remapping_referenced, remapping_renaming, remapping_undefined, remapping_undefined_p, renaming_new, renaming_old, src, and x.

Referenced by remapping_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

add_to_list_of_ranges_list()

list add_to_list_of_ranges_list	(	list	l,
		range	r
	)

first time

else

Definition at line 51 of file message-utils.c.

{
    if (ENDP(l)) /* first time */
        return CONS(LIST, CONS(RANGE, r, NIL), NIL);
 
    /* else */
    MAPL(cc,
     {
         list lr = CONSP(CAR(cc));
         assert(!ENDP(lr));
         lr = gen_nconc(lr, CONS(RANGE, r, NIL));
     },
         l);
 
    return(l);
}

References assert, CAR, CONS, CONSP, ENDP, gen_nconc(), LIST, MAPL, NIL, and RANGE.

Referenced by atomize_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

AddCommonToHostAndNodeModules()

void AddCommonToHostAndNodeModules

(

entity

common

)

Parameters

common

ommon

Definition at line 371 of file hpfc-util.c.

{
    AddCommonToModule(common, node_module, (void (*)())store_new_node_variable, NODE_NAME);
    AddCommonToModule(common, host_module, (void (*)())store_new_host_variable, HOST_NAME);
}

References AddCommonToModule(), host_module, HOST_NAME, node_module, NODE_NAME, store_new_host_variable(), and store_new_node_variable().

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

AddCommonToModule()

void AddCommonToModule	(	entity	,
		entity	,
		void(*)(void)	,
		string
	)

AddEntityToHostAndNodeModules()

void AddEntityToHostAndNodeModules

(

entity

e

)

AddEntityToHostAndNodeModules.

added because of some entity errors.

Definition at line 298 of file hpfc-util.c.

{
    entity new_node = AddEntityToModule(e, node_module),
           new_host = entity_undefined;
 
    if (!bound_new_node_p(e))
        store_new_node_variable(new_node, e);
    else
        AddEntityToDeclarations(load_new_node(e), node_module);
 
    if (!array_distributed_p(e))
    {
        new_host = AddEntityToModule(e, host_module);
 
        if (!bound_new_host_p(e))
            store_new_host_variable(new_host, e),
            /* 
             * added because of some entity errors.
             */
            store_new_host(new_node, new_host),
            store_new_node(new_host, new_node); 
        else
            AddEntityToDeclarations(load_new_host(e), host_module);
    }
}

References AddEntityToDeclarations(), AddEntityToModule(), array_distributed_p(), bound_new_host_p(), bound_new_node_p(), entity_undefined, host_module, load_new_host(), load_new_node(), node_module, store_new_host(), store_new_host_variable(), store_new_node(), and store_new_node_variable().

Referenced by generate_parallel_body(), generate_read_of_ref_for_all(), generate_read_of_ref_for_computer(), generate_update_distributed_value_from_host(), and init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

AddOnceToIndicesList()

list AddOnceToIndicesList	(	list	l,
		list	lsyn
	)

Parameters

lsyn

syn

Definition at line 188 of file compiler-util.c.

{
    MAP(SYNTAX, s,
        if (!is_in_syntax_list(reference_variable(syntax_reference(s)), lsyn))
             lsyn = CONS(SYNTAX, s, lsyn),
        l);
 
    gen_free_list(l);
    return(lsyn);
}

References CONS, gen_free_list(), is_in_syntax_list(), MAP, reference_variable, SYNTAX, and syntax_reference.

Referenced by hpf_compile_parallel_body(), and lIndicesOfRef().

Here is the call graph for this function:

Here is the caller graph for this function:

align_check()

bool align_check	(	reference	r1,
		reference	r2,
		list *	plvect,
		list *	plkind
	)

computes the shift vector that links the two references, true if every thing is ok, i.e.

the vector is ok for the distributed dimensions... The vector considered here is just a list of integers. conditions: same template

default value, used in the shift case !

default value, used in the const case !

replication, say it is not aligned

replicated reference...

a(i) -> t(i,1), b(i,j)->t(i,j), should detect do i a(i) = b(i,1) as aligned...

??? this could be managed later in this function...

should be ok, even if a delta is induced, if it stays on the same processor along this dimension. The case should also be managed downward, when playing with local updates. ??? maybe there is also a consequence on the send/receive symetry, in order to put the message where it should be...

it is checked later whether the data are on the same processor or not.

now we have everything to check whether it is aligned... and to compute the shift necessary to the overlap analysis.

something is true!

just check whether aligned or not

even in the constant case ! not aligned

aligned... ??? bug if not 1: later on, because decl shift

4 cases study with bconst and bshift, plus the rates

what should be the relevent information(s) ??? not only d, but shift2 and t2 may be usefull either ??? what about rates!=1 ? decl shift problem added.

say not aligned...

??? decl shift problem may occur here as well

??? I should do something with blcnst2?

well, say not aligned, but one to many or many to one communications may be used...

ith dimension of e2 is not distributed

may be used to generate RSDs

else the local constant should be detected, for onde24...

Parameters

r1	1
r2	2
plvect	lvect
plkind	lkind

Definition at line 190 of file align-checker.c.

{
    int procdim, i, ne2dim;
    entity e1, e2;
    align a1, a2;
    bool ok = true;
    list li1, li2;
 
    e1 = reference_variable(r1),
    e2 = reference_variable(r2);
    a1 = load_hpf_alignment(e1),
    a2 = load_hpf_alignment(e2);
    li1 = reference_indices(r1),
    li2 = reference_indices(r2);
    *plvect = NIL;
    *plkind = NIL;
 
    pips_debug(7, "with references to %s[DIM=%zd] and %s[DIM=%zd]\n",
          entity_name(e1), gen_length(li1), entity_name(e2), gen_length(li2));
 
    ne2dim = NumberOfDimension(e2);
    
    if (!conformant_templates_p(align_template(a1),align_template(a2)))
    {
        pips_debug(5, "different templates\n");
 
        for (i=1 ; i<=ne2dim ; i++)
            if (ith_dim_distributed_p(e2, i, &procdim))
            {
                *plkind = gen_nconc(*plkind, CONS(INT, not_aligned, NIL));
                *plvect = gen_nconc(*plvect, CONS(PVECTOR,
                                                  (VECTOR) VECTEUR_NUL, NIL));
            }
            else
            {
                *plkind = gen_nconc(*plkind, CONS(INT, local_star, NIL));
                *plvect = gen_nconc(*plvect, CONS(PVECTOR,
                                                  (VECTOR) VECTEUR_NUL, NIL));
            }
        
        return ok;
    }
 
    ifdebug(8)
         {
             fprintf(stderr, "[align_check] references are: ");
             print_reference(r1);
             fprintf(stderr, " and ");
             print_reference(r2);
             fprintf(stderr, "\n");
         }
 
    for (i=1 ; i<=ne2dim ; i++)
    {
        expression indice1, indice2; 
        int 
            affr1 = 1, /* default value, used in the shift case ! */
            affr2 = 1,
            shft1, shft2;
        entity
            index1 = NULL, /* default value, used in the const case ! */
            index2 = NULL;
        bool
            baffin1, baffin2,
            bshift1, bshift2,
            bconst1, bconst2,
            blcnst2=0;
 
        pips_debug(8, "considering dimension %d of %s\n", i, entity_name(e2));
 
        indice2 = EXPRESSION(gen_nth(i-1, li2));
 
        baffin2 = affine_expression_of_loop_index_p(indice2, 
                                                    &index2, &shft2, &affr2);
        bshift2 = shift_expression_of_loop_index_p(indice2, &index2, &shft2);
        bconst2 = hpfc_integer_constant_expression_p(indice2, &shft2);
        if (!(baffin2 || bshift2 || bconst2))
            blcnst2 = local_integer_constant_expression(indice2);
        
        if (ith_dim_distributed_p(e2, i, &procdim))
        {
            alignment
                a2 = FindArrayDimAlignmentOfArray(e2, i),
                a1 = FindTemplateDimAlignmentOfArray(e1,
                                 alignment_templatedim(a2));
            int
                dim1=((a1!=alignment_undefined)?(alignment_arraydim(a1)):(-1)),
                rate1, rate2, 
                cnst1, cnst2;
 
            rate2   = HpfcExpressionToInt(alignment_rate(a2));
            cnst2   = HpfcExpressionToInt(alignment_constant(a2));
 
            if ((dim1<0) || /* replication, say it is not aligned */
                ((dim1==0) && (!bconst2))) /* replicated reference...*/
            {
                pips_debug(8, "%s[DIM=%d] not aligned aff %d shi %d cst %d\n",
                           entity_name(e2), i, baffin2, bshift2, bconst2);
 
                *plkind = gen_nconc(*plkind, CONS(INT, not_aligned, NIL));
                *plvect = gen_nconc(*plvect, CONS(PVECTOR, 
                                                  (VECTOR) VECTEUR_NUL, NIL));
            }
            else
            if ((dim1==0) && (bconst2))
            {
                /* a(i) -> t(i,1), b(i,j)->t(i,j), should detect 
                 * do i a(i) = b(i,1) as aligned...
                 *
                 * ??? this could be managed later in this function...
                 */
 
                int t1 = HpfcExpressionToInt(alignment_constant(a1)),
                    t2 = rate2*shft2+cnst2;
                
                /* should be ok, even if a delta is induced, if it stays
                 * on the same processor along this dimension. The case
                 * should also be managed downward, when playing with 
                 * local updates. 
                 * ??? maybe there is also a consequence on the 
                 * send/receive symetry, in order to put the message where it
                 * should be...
                 */
 
                /* it is checked later whether the data are on the same 
                 * processor or not.
                 */
 
                *plkind = gen_nconc(*plkind, CONS(INT, aligned_constant, NIL));
                *plvect = gen_nconc(*plvect,
                                    CONS(PVECTOR, (VECTOR)
                   vect_add(vect_new(TEMPLATEV, int_to_value(t2)),
                            vect_new(DELTAV, int_to_value(t2-t1))),
                                         NIL));
            }
            else
            {
                indice1 = EXPRESSION(gen_nth(dim1-1, li1));
 
                rate1   = HpfcExpressionToInt(alignment_rate(a1));
                cnst1   = HpfcExpressionToInt(alignment_constant(a1));
 
                baffin1 = affine_expression_of_loop_index_p
                    (indice1, &index1, &shft1, &affr1);
                bshift1 = shift_expression_of_loop_index_p
                    (indice1, &index1, &shft1);
                bconst1 = hpfc_integer_constant_expression_p
                    (indice1, &shft1);          
 
                /* now we have everything to check whether it is aligned...
                 * and to compute the shift necessary to the overlap analysis.
                 */
 
                if (!((baffin1 || bshift1 || bconst1) &&
                      (baffin2 || bshift2 || bconst2)))
                {
                    *plkind = gen_nconc(*plkind, CONS(INT, not_aligned, NIL));
                    *plvect = gen_nconc(*plvect, CONS(PVECTOR,(VECTOR) 
                                                      VECTEUR_NUL, NIL));
                }
                else /* something is true! */
                if (baffin1 || baffin2) /* just check whether aligned or not */
                {
                    int
                        r1 = ((bconst1)?(0):(rate1*affr1)),
                        r2 = ((bconst2)?(0):(rate2*affr2)),
                        c1 = rate1*shft1+cnst1,
                        c2 = rate2*shft2+cnst2;
 
                    /* even in the constant case ! not aligned */
                    if ((index1!=index2) ||
                        (r1!=r2) || (c1!=c2))
                    {
                        *plkind = 
                            gen_nconc(*plkind, CONS(INT, not_aligned, NIL));
                        *plvect = 
                            gen_nconc(*plvect, CONS(PVECTOR, 
                                          (VECTOR) VECTEUR_NUL, NIL));
                    }    
                    else /* aligned... ??? 
                          * bug if not 1: later on, because decl shift
                          */
                    {
                        *plkind = 
                            gen_nconc(*plkind, CONS(INT, aligned_star, NIL));
                        *plvect = 
                            gen_nconc(*plvect, CONS(PVECTOR,
                                         (VECTOR) VECTEUR_NUL, NIL));
                    }
                }
                else /* 4 cases study with bconst and bshift, plus the rates */
                if (bconst1 && bconst2)
                {
                    int
                        t1 = (rate1*shft1+cnst1),
                        t2 = (rate2*shft2+cnst2),
                        d  = (t2-t1);
 
                    /* what should be the relevent information(s) ??? 
                     * not only d, but shift2 and t2 may be usefull either
                     * ??? what about rates!=1 ? decl shift problem added.
                     */
 
                    *plkind = 
                        gen_nconc(*plkind, CONS(INT, aligned_constant, NIL));
                    *plvect = 
                        gen_nconc(*plvect, 
                                  CONS(PVECTOR, (VECTOR)
                                       vect_make(VECTEUR_NUL,
                                                 DELTAV, int_to_value(d),
                                                 TEMPLATEV, int_to_value(t2),
                                                 TCST, int_to_value(shft2)),
                                       NIL));
                }
                else /* say not aligned... */
                if ((rate1!=1) || (rate2!=1) || (index1!=index2)) 
                {
                    *plkind = gen_nconc(*plkind, 
                                        CONS(INT, not_aligned, NIL));
                    *plvect = gen_nconc(*plvect,
                                CONS(PVECTOR, (VECTOR) VECTEUR_NUL, NIL));
                }
                else
                if (bshift1 && bshift2)
                {
                    /* ??? decl shift problem may occur here as well */
                    int
                        tc1   = (shft1+cnst1),
                        tc2   = (shft2+cnst2),
                        shift = (tc2-tc1);
 
                    *plkind = gen_nconc(*plkind, CONS(INT, aligned_shift, NIL));
                    *plvect = gen_nconc
                        (*plvect, 
                         CONS(PVECTOR, (VECTOR)
                              vect_make(VECTEUR_NUL,
                                        TSHIFTV, int_to_value(shift),
                                        (Variable) index1, VALUE_ONE,
                                        TCST, int_to_value(shft2)),
                              NIL));
                }
                else /* ??? I should do something with blcnst2? */
                {
                    /* well, say not aligned, but one to many or many to one
                     * communications may be used...
                     */
                    *plkind = 
                        gen_nconc(*plkind, CONS(INT, not_aligned, NIL));
                    *plvect = 
                        gen_nconc(*plvect,
                                  CONS(PVECTOR, (VECTOR)  VECTEUR_NUL, NIL));
                }                                
            }
        }
        else /* ith dimension of e2 is not distributed */
        {
            if (!(baffin2 || bshift2 || bconst2 || blcnst2))
            {
                *plkind = gen_nconc(*plkind, CONS(INT, local_star, NIL));
                *plvect = gen_nconc(*plvect,
                                    CONS(PVECTOR, (VECTOR) VECTEUR_NUL, NIL));
            }
            else
            if (baffin2) /* may be used to generate RSDs */
            {
                *plkind = gen_nconc(*plkind, CONS(INT, local_affine, NIL));
                *plvect = 
                    gen_nconc(*plvect, 
                       CONS(PVECTOR, (VECTOR)
                            vect_make(VECTEUR_NUL,
                                      (Variable) index2, int_to_value(affr2),
                                      TCST, int_to_value(shft2)),
                            NIL));
            }
            else
            if (bshift2)
            {
                *plkind = gen_nconc(*plkind, CONS(INT, local_shift, NIL));
                *plvect = 
                    gen_nconc(*plvect, 
                              CONS(PVECTOR, (VECTOR)
                                   vect_make(VECTEUR_NUL,
                                             (Variable) index2, VALUE_ONE,
                                             TCST, int_to_value(shft2)),
                                   NIL));
            }
            else
            if (bconst2)
            {
                *plkind = gen_nconc(*plkind, CONS(INT, local_constant, NIL));
                *plvect = gen_nconc(*plvect, CONS(PVECTOR, (VECTOR)
                             vect_new(TCST, int_to_value(shft2)),
                                                  NIL));
            }
            /* else the local constant should be detected, for onde24... */
            else
            if (blcnst2)
            {
                *plkind = gen_nconc(*plkind, CONS(INT, local_form_cst, NIL));
                *plvect = 
                    gen_nconc(*plvect, 
                              CONS(PVECTOR,  (VECTOR)
                           normalized_linear(expression_normalized(indice2)),
                                   NIL));
            }
        }
    }
 
    ifdebug(8)
    {
        list l;
        fprintf(stderr, "[align_check] returning: ");
        for (l=*plkind; l; POP(l))
            fprintf(stderr, "%"PRIdPTR", ", INT(CAR(l)));
        fprintf(stderr, "\n");
    }
 
    return ok;
}

References affine_expression_of_loop_index_p(), align_template, aligned_constant, aligned_shift, aligned_star, alignment_arraydim, alignment_constant, alignment_rate, alignment_templatedim, alignment_undefined, CAR, conformant_templates_p(), CONS, DELTAV, entity_name, EXPRESSION, expression_normalized, FindArrayDimAlignmentOfArray, FindTemplateDimAlignmentOfArray, fprintf(), gen_length(), gen_nconc(), gen_nth(), hpfc_integer_constant_expression_p(), HpfcExpressionToInt(), ifdebug, INT, int_to_value, ith_dim_distributed_p(), load_hpf_alignment(), local_affine, local_constant, local_form_cst, local_integer_constant_expression(), local_shift, local_star, NIL, normalized_linear, not_aligned, NumberOfDimension(), ok, pips_debug, POP, print_reference(), PVECTOR, reference_indices, reference_variable, shift_expression_of_loop_index_p(), TCST, TEMPLATEV, TSHIFTV, VALUE_ONE, vect_add(), vect_make(), vect_new(), VECTEUR_NUL, and VECTOR.

Referenced by Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

alignments_compatible_p()

bool alignments_compatible_p	(	entity	e1,
		int	dim1,
		entity	e2,
		int	dim2
	)

bool alignments_compatible_p(entity e1, int dim1, entity e2, int dim2)

what: whether e1 and e2 dimensions dim1 and dim2 are aligned. how: basic low level comparison input: entities and dimension numbers output: the bool result side effects:

• uses alignment internal descriptions bugs or features:
• ??? should be relative to a reference, instead of assuming mere indexes

Parameters

e1	1
dim1	im1
e2	2
dim2	im2

Definition at line 678 of file hpfc-util.c.

{
    int tdim1, rate1, shift1, tdim2, rate2, shift2;
 
    get_alignment(e1, dim1, &tdim1, &rate1, &shift1);
    get_alignment(e2, dim2, &tdim2, &rate2, &shift2);
 
    if (tdim1!=tdim2) return false;
    if (!tdim1 && !tdim2) return true;
    
    return rate1==rate2 && shift1==shift2;
}

References get_alignment().

Referenced by references_aligned_p().

Here is the call graph for this function:

Here is the caller graph for this function:

alive_arrays()

list alive_arrays	(	statement	s,
		entity	t
	)

what: returns the list of alive arrays for statement s and template t.

how: uses the alive_synonym, and computes the defaults. input: statement s and template t which are of interest. output: a list of entities which is allocated. side effects: none. of entities

of entities

to tag seen primaries.

??? well, it is not necessarily initialized, I guess...

first the alive list is scanned.

second the defaults are looked for. namely the primary entities.

Definition at line 1504 of file dynamic.c.

{
    list /* of entities */ l = NIL, lseens = NIL; /* to tag seen primaries. */
 
    pips_assert("template", entity_template_p(t) && primary_entity_p(t));
    pips_debug(7, "for template %s\n", entity_name(t));
 
    /* ??? well, it is not necessarily initialized, I guess...
     */
    if (!bound_alive_synonym_p(s))
        store_alive_synonym(s, make_entities(NIL));
 
    /*   first the alive list is scanned.
     */
    MAP(ENTITY, array,
    {
        entity ta = align_template(load_hpf_alignment(array));
 
        if (safe_load_primary_entity(ta)==t)
            l = CONS(ENTITY, array, l);
 
        pips_debug(8, "adding %s as alive\n", entity_name(array));
        
        lseens = CONS(ENTITY, load_primary_entity(array), lseens);
    },
        entities_list(load_alive_synonym(s)));
 
    /*   second the defaults are looked for. namely the primary entities.
     */
    MAP(ENTITY, array,
    {
        if (primary_entity_p(array) && !gen_in_list_p(array, lseens))
        {
            if (align_template(load_hpf_alignment(array))==t)
                l = CONS(ENTITY, array, l);
            
            pips_debug(8, "adding %s as default\n", entity_name(array));
        
            lseens = CONS(ENTITY, array, lseens);
        }
    },
        list_of_distributed_arrays());
 
    DEBUG_ELST(9, "seen arrays", lseens);
    gen_free_list(lseens);
 
    DEBUG_ELST(7, "returned alive arrays", l);
    return l;
}

References align_template, array, CONS, DEBUG_ELST, entities_list, ENTITY, entity_name, entity_template_p(), gen_free_list(), gen_in_list_p(), list_of_distributed_arrays(), load_hpf_alignment(), load_primary_entity(), make_entities(), MAP, NIL, pips_assert, pips_debug, primary_entity_p, and safe_load_primary_entity().

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

argument_bound_entity()

entity argument_bound_entity	(	entity	module,
		entity	array,
		bool	upper,
		int	dim
	)

Parameters

module	odule
array	rray
upper	pper
dim	im

Definition at line 499 of file run-time.c.

{
    entity result;
    string name = bound_parameter_name(array, upper? UPPER: LOWER, dim);
 
    result = find_or_create_typed_entity(name, module_local_name(module), 
                                         is_basic_int);
 
    free(name);
    return result;
}

References array, bound_parameter_name(), find_or_create_typed_entity(), free(), is_basic_int, LOWER, module, module_local_name(), and UPPER.

Referenced by create_bound_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

array_access_to_array_ranges()

list array_access_to_array_ranges	(	reference	r,
		list	lkref,
		list	lvref
	)

this dimension shouldn't be used, so I put there whatever I want... ??? mouais, the information is in the vector, I think.

??? should check that it is ok

Parameters

lkref	kref
lvref	vref

Definition at line 569 of file message-utils.c.

{
    entity array = reference_variable(r);
    int dim = 1;
    list li  = reference_indices(r), lk  = lkref, lv  = lvref, lra = NIL,
        ldim = variable_dimensions(type_variable(entity_type(array)));
 
    pips_debug(7, "considering array %s\n", entity_name(array));
 
    for (; li; POP(li), POP(lk), POP(lv), POP(ldim), dim++)
    {
        access a = INT(CAR(lk));
        Pvecteur v = (Pvecteur) PVECTOR(CAR(lv));
        normalized n = expression_normalized(EXPRESSION(CAR(li)));
        
        pips_debug(8, "DIM=%d[%d]\n", dim, a);
 
        switch (access_tag(a))
        {
        case local_form_cst:
        {
            /* this dimension shouldn't be used, 
             * so I put there whatever I want...
             * ??? mouais, the information is in the vector, I think.
             */
            lra = gen_nconc(lra,
                            CONS(RANGE,
                                 make_range(expression_undefined,
                                            expression_undefined,
                                            expression_undefined),
                                 NIL));
            
            break;
        }
        case aligned_constant:
        case local_constant:
        {
            Value tc = vect_coeff(TCST, v);
            expression arraycell = Value_to_expression(tc);
 
            lra = gen_nconc(lra,
                            CONS(RANGE,
                                 make_range(arraycell, arraycell,
                                            int_to_expression(1)),
                                 NIL));
            break;
        }
        case aligned_shift:
        case local_shift:
        {
            range
                /* ??? should check that it is ok */
                rg = loop_index_to_range
                    ((entity) var_of(vect_del_var(v, TCST)));
            expression
                rl = range_lower(rg),
                ru = range_upper(rg),
                in = range_increment(rg),
                al = expression_undefined,
                au = expression_undefined;
            Value vdt =  vect_coeff(TCST, (Pvecteur) normalized_linear(n));
            int lb = -1, ub = -1, dt = VALUE_TO_INT(vdt);
 
            if (expression_integer_constant_p(rl))
                lb = HpfcExpressionToInt(rl),
                al = int_to_expression(lb-dt);
            else
                al = copy_expression(dimension_lower(DIMENSION(CAR(ldim))));
 
            if (expression_integer_constant_p(ru))
                ub = HpfcExpressionToInt(ru),
                au = int_to_expression(ub-dt);
            else
                au = copy_expression(dimension_upper(DIMENSION(CAR(ldim))));
 
            lra = gen_nconc(lra, CONS(RANGE, make_range(al, au, in), NIL));
            break;
        }
        case aligned_affine:
        case local_affine:
        {
            Pvecteur v2 = vect_del_var(v, TCST);
            entity index = (entity) var_of(v2);
            range rg = loop_index_to_range(index);
            Value vdt =  vect_coeff(TCST, (Pvecteur) normalized_linear(n));
            int rate = val_of(v2),
                in = HpfcExpressionToInt(range_increment(rg)),
                lb = HpfcExpressionToInt(range_lower(rg)),
                ub = HpfcExpressionToInt(range_upper(rg)),
                dt = VALUE_TO_INT(vdt);
            expression
                ai = int_to_expression(rate*in),
                al = int_to_expression(rate*lb-dt),
                au = int_to_expression(rate*ub-dt);
 
            lra = gen_nconc(lra, CONS(RANGE, make_range(al, au, ai), NIL));
            break;
        }
        default:
            pips_internal_error("unexpected but maybe legal access");
            break;
        }
    }
    
    return(lra);
}

References access, access_tag, aligned_affine, aligned_constant, aligned_shift, array, CAR, CONS, copy_expression(), DIMENSION, dimension_lower, dimension_upper, entity_name, entity_type, EXPRESSION, expression_integer_constant_p(), expression_normalized, expression_undefined, gen_nconc(), HpfcExpressionToInt(), INT, int_to_expression(), local_affine, local_constant, local_form_cst, local_shift, loop_index_to_range(), make_range(), NIL, normalized_linear, pips_debug, pips_internal_error, POP, PVECTOR, RANGE, range_increment, range_lower, range_upper, reference_indices, reference_variable, tc, TCST, type_variable, val_of, Value_to_expression(), VALUE_TO_INT, var_of, variable_dimensions, vect_coeff(), and vect_del_var().

Referenced by loop_nest_guard().

Here is the call graph for this function:

Here is the caller graph for this function:

array_distributed_p()

bool array_distributed_p

(

entity

)

Referenced by add_bound_arguments(), AddEntityToHostAndNodeModules(), caller_list_of_bounds(), check_for_similarity(), clean_distributed_io_system(), compile_reduction(), DistArraysEffects(), drop_distributed_arguments(), entity_to_hpf_align_constraints(), entity_to_new_declaration(), expression_simple_nondist_p(), FindRefToDistArray_syntax_rewrite(), FindRefToDistArrayInStatement_call_filter(), generate_c1_alpha(), generate_c1_beta(), generate_compute_local_indices(), generate_copy_loop_nest(), generate_get_value_locally(), generate_io_collect_or_update(), generate_io_system(), generate_read_of_ref_for_all(), generate_read_of_ref_for_computer(), generate_receive_from_computer(), generate_send_to_computer(), generate_shared_io_system(), generate_system_for_distributed_variable(), generate_update_distributed_value_from_host(), generate_update_private_value_from_host(), get_alignment(), get_ith_dim_new_declaration(), hpf_compile_call(), hpfc_call_with_distributed_args_p(), hpfc_check_for_similarities(), hpfc_compute_align_constraints(), hpfc_compute_entity_to_new_declaration(), hpfc_compute_unicity_constraints(), hpfc_decision(), hpfc_translate_call_with_distributed_args(), initial_alignment(), io_efficient_compile(), loop_flt(), lUpdateExpr_but_distributed(), new_declaration_tag(), NewDeclarationOfDistributedArray(), one_align_directive(), one_distribute_directive(), put_variables_in_ordered_lists(), references_aligned_p(), replicated_p(), STATIC_LIST_OF_HPF_OBJECTS(), store_a_new_declaration(), subarray_shift_assignment_p(), and update_overlaps_in_caller().

array_distribution_similar_p()

bool array_distribution_similar_p	(	entity	a1,
		entity	a2
	)

conformant processors ??? could assume that P(1:1,1:n) is conformant to P'(1:n)?

considering ith dim of proc

conformant distributions

if the size is 1, whatever the distribution it is ok!

conformant alignments for that pe dim !!! the HPF mapping "semantics" insure that the corresponding dimension is distributed!

Parameters

a1	1
a2	2

Definition at line 578 of file dynamic.c.

{
    align 
        al1 = load_hpf_alignment(a1),
        al2 = load_hpf_alignment(a2);
    entity 
        t1 = align_template(al1),
        t2 = align_template(al2);
    distribute 
        d1 = load_hpf_distribution(t1),
        d2 = load_hpf_distribution(t2);
    entity
        p1 = distribute_processors(d1),
        p2 = distribute_processors(d2);
    int i, td1, td2,
        ndimdist = NumberOfDimension(p1);
 
    pips_assert("same primary", 
                load_primary_entity(a1)==load_primary_entity(a2));
 
    pips_debug(6, "comparing %s and %s\n", entity_name(a1), entity_name(a2));
 
    /* conformant processors 
     * ??? could assume that P(1:1,1:n) is conformant to P'(1:n)?
     */
    if (!conformant_entities_p(p1, p2)) 
        RET("different processors", false);
    
    for (i=1; i<=ndimdist; i++) /* considering ith dim of proc */
    {
        /* conformant distributions
         */
        distribution 
            x1 = FindDistributionOfProcessorDim
              (distribute_distribution(d1), i, &td1),
            x2 = FindDistributionOfProcessorDim
              (distribute_distribution(d2), i, &td2);
        alignment at1, at2;
        int dsize = SizeOfIthDimension(p1,i);
        
        /* if the size is 1, whatever the distribution it is ok! */
        if (dsize!=1)
        {
            if (!same_distribution_p(x1, x2)) 
                RET("different distribution", false);
            
            /* conformant alignments for that pe dim
             * !!! the HPF mapping "semantics" insure that the corresponding 
             * dimension is distributed!
             */
            at1 = FindAlignmentOfTemplateDim(align_alignment(al1), td1);
            at2 = FindAlignmentOfTemplateDim(align_alignment(al2), td2);
 
            if (!same_alignment_p(a1,t1,at1,a2,t2,at2)) 
                RET("different alignment", false);
        }
    }
 
    pips_debug(6, "similar distributions!\n");
    return true;
}

References align_alignment, align_template, conformant_entities_p(), distribute_distribution, distribute_processors, entity_name, FindAlignmentOfTemplateDim(), FindDistributionOfProcessorDim(), load_hpf_alignment(), load_hpf_distribution(), load_primary_entity(), NumberOfDimension(), pips_assert, pips_debug, RET, same_alignment_p(), same_distribution_p(), and SizeOfIthDimension().

Referenced by check_for_similarity().

Here is the call graph for this function:

Here is the caller graph for this function:

array_lower_upper_bounds_list()

list array_lower_upper_bounds_list

(

entity

array

)

of expressions

of expression

interleave both lists (just for fun:-)

Parameters

array

rray

Definition at line 539 of file run-time.c.

{
    list /* of expression */ lb = array_bounds_list(array, false),
                             lu = array_bounds_list(array, true),
                             l = lb, lnb, lnu;
 
    if (!l) return NIL;
    
    /* interleave both lists (just for fun:-)
     */
    for(lnb=CDR(lb), lnu=CDR(lu); lb; 
        CDR(lb)=lu, CDR(lu)=lnb, 
        lb=lnb, lnb=lnb?CDR(lnb):NIL, lu=lnu, lnu=lnu?CDR(lnu):NIL);
 
    return l;
}

References array, array_bounds_list(), CDR, and NIL.

Referenced by compile_reduction(), generate_subarray_shift(), and st_generate_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

array_ranges_to_template_ranges()

list array_ranges_to_template_ranges	(	entity	array,
		list	lra
	)

scratched

replication

non distributed dimension, so not used...

Parameters

array	rray
lra	ra

Definition at line 426 of file message-utils.c.

{
    align a = load_hpf_alignment(array);
    entity template = align_template(a);
    list la = align_alignment(a), lrt = NIL;
    int i = 1;
    
    for (i=1 ; i<=NumberOfDimension(template) ; i++)
    {
        alignment al = FindAlignmentOfTemplateDim(la, i);
        int arraydim = alignment_undefined_p(al)? -1: alignment_arraydim(al);
 
        if (arraydim==-1) /* scratched */
        {
            dimension d = FindIthDimension(template, i);
            lrt = gen_nconc(lrt,
               CONS(RANGE,
                    make_range(copy_expression(dimension_lower(d)),
                               copy_expression(dimension_upper(d)),
                               int_to_expression(1)), NIL));
        } 
        else if (arraydim==0) /* replication */
        {
            expression b = alignment_constant(al);
 
            lrt = gen_nconc(lrt,
                            CONS(RANGE,
                                 make_range(b, b, int_to_expression(1)),
                                 NIL));
        }
        else
        {
            range rg = RANGE(gen_nth(arraydim-1, lra));
 
            if (expression_undefined_p(range_lower(rg)))
            {
                /* non distributed dimension, so not used...
                 */
                lrt = gen_nconc(lrt, CONS(RANGE, 
                                          make_range(expression_undefined,
                                                     expression_undefined,
                                                     expression_undefined),
                                          NIL));
            }
            else
            {
                int
                    a  = HpfcExpressionToInt(alignment_rate(al)),
                    b  = HpfcExpressionToInt(alignment_constant(al)),
                    lb, ub, in;
                expression tl, tu, ti;
 
                lb = HpfcExpressionToInt(range_lower(rg));
                ub = HpfcExpressionToInt(range_upper(rg));
                in = HpfcExpressionToInt(range_increment(rg));
                tl = int_to_expression(a*lb+b);
                tu = int_to_expression(a*ub+b);
                ti = int_to_expression(a*in);
 
                lrt = gen_nconc(lrt,
                                CONS(RANGE,
                                     make_range(tl, tu, ti),
                                     NIL));
            }
        }
    }
    
    return(lrt);            
}

References align_alignment, align_template, alignment_arraydim, alignment_constant, alignment_rate, alignment_undefined_p, array, CONS, copy_expression(), dimension_lower, dimension_upper, expression_undefined, expression_undefined_p, FindAlignmentOfTemplateDim(), FindIthDimension(), gen_nconc(), gen_nth(), HpfcExpressionToInt(), int_to_expression(), load_hpf_alignment(), make_range(), NIL, NumberOfDimension(), RANGE, range_increment, range_lower, and range_upper.

Referenced by loop_nest_guard(), and one_message_guards_and_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

array_synonym_aligned_as()

entity array_synonym_aligned_as	(	entity	array,
		align	a
	)

entity array_synonym_aligned_as(array, a) entity array; align a;

what: finds or creates a new entity aligned as needed. input: an array (which must be dynamic) and an align output: returns an array aligned as specified by align a side effects:

• creates a new entity if necessary.
• this entity is stored as a synonym of array, and tagged as dynamic.
• the align is freed if not used. bugs or features:

the one found is returned

else no compatible array does exist, so one must be created

Parameters

array

rray

Definition at line 449 of file dynamic.c.

{
    ifdebug(8)
    {
        pips_debug(8, "array %s\n", entity_name(array));
        print_align(a);
    }
 
    MAP(ENTITY, ar,
    {
        if (same_align_p(load_hpf_alignment(ar), a))
        {
            free_align(a);
            return ar;    /* the one found is returned */
        }
    },
        entities_list(load_dynamic_hpf(array)));
 
    /*  else no compatible array does exist, so one must be created
     */
    return new_synonym_array(array, a);
}

References array, entities_list, ENTITY, entity_name, free_align(), ifdebug, load_dynamic_hpf(), load_hpf_alignment(), MAP, new_synonym_array(), pips_debug, print_align(), and same_align_p().

Referenced by hpfc_translate_call_with_distributed_args(), one_align_directive(), and one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

atomic_accesses_only_p()

bool atomic_accesses_only_p

(

statement

)

block_distributed_p()

bool block_distributed_p

(

entity

array

)

o-analysis.c

o-analysis.c

distributed && (nd==is_hpf_newdecl_none)) ? ??? the case is not handled later on

Parameters

array

rray

Definition at line 44 of file o-analysis.c.

{
    int dim = NumberOfDimension(array);
    tag n;
 
    for(; dim>0; dim--)
    {
        n = new_declaration_tag(array, dim);
        if ((n==is_hpf_newdecl_gamma) || (n==is_hpf_newdecl_delta))
            /* distributed && (nd==is_hpf_newdecl_none)) ?
             * ??? the case is not handled later on 
             */
            return(false);
    }
 
    return(true);
}

References array, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, new_declaration_tag(), and NumberOfDimension().

Referenced by message_manageable_p(), Overlap_Analysis(), and subarray_shift_assignment_p().

Here is the call graph for this function:

Here is the caller graph for this function:

bound_dynamic_hpf_p()

bool bound_dynamic_hpf_p

(

entity

)

Referenced by root_statement_remapping_inits(), safe_load_primary_entity(), and set_entity_as_dynamic().

Here is the caller graph for this function:

bound_hpf_alignment_p()

bool bound_hpf_alignment_p

(

entity

)

Referenced by one_align_directive(), and one_distribute_directive().

Here is the caller graph for this function:

bound_hpf_distribution_p()

bool bound_hpf_distribution_p

(

entity

)

bound_hpf_number_p()

bool bound_hpf_number_p

(

entity

)

Referenced by GiveToHpfObjectsTheirNumber().

Here is the caller graph for this function:

bound_hpf_reductions_p()

bool bound_hpf_reductions_p

(

statement

)

Referenced by handle_reduction_directive(), and hpf_compiler().

Here is the caller graph for this function:

bound_maybeuseful_mappings_p()

bool bound_maybeuseful_mappings_p

(

statement

)

bound_new_host_p()

bool bound_new_host_p

(

entity

)

Referenced by add_declaration_to_host_and_link(), AddEntityToHostAndNodeModules(), debug_host_node_variables(), io_efficient_compile(), NewVariableForModule(), and update_object_for_module().

Here is the caller graph for this function:

bound_new_node_p()

bool bound_new_node_p

(

entity

)

Referenced by AddEntityToHostAndNodeModules(), debug_host_node_variables(), make_host_and_node_modules(), NewDeclarationOfDistributedArray(), NewVariableForModule(), set_similar_mappings_for_updates(), update_object_for_module(), and update_overlaps_in_caller().

Here is the caller graph for this function:

bound_old_host_p()

bool bound_old_host_p

(

entity

)

Referenced by debug_host_node_variables().

Here is the caller graph for this function:

bound_old_node_p()

bool bound_old_node_p

(

entity

)

Referenced by debug_host_node_variables().

Here is the caller graph for this function:

bound_overlap_status_p()

bool bound_overlap_status_p

(

entity

)

Referenced by create_overlaps(), get_overlap(), and set_overlap().

Here is the caller graph for this function:

bound_parameter_name()

string bound_parameter_name	(	entity	array,
		string	side,
		int	dim
	)

returns a name for the bound of the declaration of array array, side side and dimension dim.

Parameters

array	rray
side	ide
dim	im

Definition at line 488 of file run-time.c.

{
    return strdup(concatenate(hpfc_main_entity_name(array), " ",
                              entity_local_name(array), " ",
                              side, int2a(dim), NULL));
}

References array, concatenate(), entity_local_name(), hpfc_main_entity_name(), int2a(), and strdup().

Referenced by argument_bound_entity(), create_parameters_h(), and hpfc_array_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

bound_primary_entity_p()

bool bound_primary_entity_p

(

entity

)

Referenced by same_primary_entity_p().

Here is the caller graph for this function:

bound_renamings_p()

bool bound_renamings_p

(

statement

)

Referenced by clean_statement(), and hpf_compiler().

Here is the caller graph for this function:

bound_similar_mapping_p()

bool bound_similar_mapping_p

(

entity

)

Referenced by check_for_similarity(), create_parameters_h(), and set_similar_mappings_for_updates().

Here is the caller graph for this function:

call_reduction_p()

bool call_reduction_p

(

call

c

)

Definition at line 87 of file special_cases.c.

{
    return hpfc_entity_reduction_p(call_function(c));
}

References call_function, and hpfc_entity_reduction_p().

Referenced by compile_reduction(), and hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_the_system()

void clean_the_system	(	Psysteme *	ps,
		list *	plrm,
		list *	pltry
	)

Parameters

ps	s
plrm	lrm
pltry	ltry

Definition at line 360 of file io-compile.c.

{
    remove_variables_from_system(ps, plrm);
    remove_variables_if_possible(ps, pltry);
 
    build_sc_nredund_2pass(ps);
    base_rm(sc_base(*ps)), sc_creer_base(*ps);
}

References base_rm, build_sc_nredund_2pass(), remove_variables_from_system(), remove_variables_if_possible(), and sc_creer_base().

Referenced by clean_distributed_io_system(), and hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

close_data_status()

void close_data_status

(

void

)

Definition at line 339 of file declarations.c.

{
    close_new_declaration();
    close_hpf_alignment();
    close_hpf_distribution();
    free_hpf_object_lists();
}

References close_hpf_alignment(), close_hpf_distribution(), and free_hpf_object_lists().

Here is the call graph for this function:

close_dynamic_hpf()

void close_dynamic_hpf

(

void

)

Referenced by close_dynamic_status().

Here is the caller graph for this function:

close_dynamic_locals()

void close_dynamic_locals

(

void

)

can't close it directly...

Definition at line 817 of file dynamic.c.

{
    close_alive_synonym();
    close_used_dynamics();
    close_modified_dynamics();
    close_reaching_mappings();
    close_leaving_mappings();
    close_remapped();
 
    /*  can't close it directly...
     */
    CONTROLMAP_MAP(s, c, 
      {
          what_stat_debug(9, s);
 
          control_statement(c) = statement_undefined;
          gen_free_list(control_successors(c)); control_successors(c) = NIL;
          gen_free_list(control_predecessors(c)); control_predecessors(c) = NIL;
      },
                   get_remapping_graph());
 
    close_remapping_graph();
}

References control_predecessors, control_statement, control_successors, CONTROLMAP_MAP, gen_free_list(), NIL, statement_undefined, and what_stat_debug.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

close_dynamic_status()

void close_dynamic_status

(

void

)

Definition at line 117 of file dynamic.c.

{
    close_dynamic_hpf();
    close_primary_entity();
    close_renamings();
    close_maybeuseful_mappings();
    close_similar_mapping();
}

References close_dynamic_hpf(), close_maybeuseful_mappings(), close_primary_entity(), close_renamings(), and close_similar_mapping().

Here is the call graph for this function:

close_entity_status()

void close_entity_status

(

void

)

Definition at line 118 of file host_node_entities.c.

{
    close_new_host();
    close_old_host();
    close_new_node();
    close_old_node();
}

References close_new_host(), close_new_node(), close_old_host(), and close_old_node().

Here is the call graph for this function:

close_hpf_alignment()

void close_hpf_alignment

(

void

)

Referenced by close_data_status().

Here is the caller graph for this function:

close_hpf_distribution()

void close_hpf_distribution

(

void

)

Referenced by close_data_status().

Here is the caller graph for this function:

close_hpf_number()

void close_hpf_number

(

void

)

Referenced by close_hpf_number_status().

Here is the caller graph for this function:

close_hpf_number_status()

void close_hpf_number_status

(

void

)

Definition at line 157 of file declarations.c.

{
    close_hpf_number();
    init_currents();
}

References close_hpf_number(), and init_currents().

Here is the call graph for this function:

close_hpf_reductions()

void close_hpf_reductions

(

void

)

close_maybeuseful_mappings()

void close_maybeuseful_mappings

(

void

)

Referenced by close_dynamic_status().

Here is the caller graph for this function:

close_new_host()

void close_new_host

(

void

)

Referenced by close_entity_status().

Here is the caller graph for this function:

close_new_node()

void close_new_node

(

void

)

Referenced by close_entity_status().

Here is the caller graph for this function:

close_old_host()

void close_old_host

(

void

)

Referenced by close_entity_status().

Here is the caller graph for this function:

close_old_node()

void close_old_node

(

void

)

Referenced by close_entity_status().

Here is the caller graph for this function:

close_overlap_status()

void close_overlap_status

(

void

)

close_primary_entity()

void close_primary_entity

(

void

)

Referenced by close_dynamic_status().

Here is the caller graph for this function:

close_renamings()

void close_renamings

(

void

)

Referenced by close_dynamic_status().

Here is the caller graph for this function:

close_similar_mapping()

void close_similar_mapping

(

void

)

Referenced by close_dynamic_status().

Here is the caller graph for this function:

close_the_dynamics()

void close_the_dynamics

(

void

)

Referenced by handle_hpf_directives().

Here is the caller graph for this function:

compile_a_pure_function()

void compile_a_pure_function

(

entity

module

)

simply copied for both host and node...

Parameters

module

odule

Definition at line 493 of file compile.c.

{
    string file_name, hn_name, dir_name, fs, ft;
 
    pips_debug(1, "compiling pure a function (%s)\n", entity_name(module));
 
    const char* prefix = module_local_name(module);
    dir_name = db_get_current_workspace_directory();
    file_name = db_get_file_resource(DBR_SOURCE_FILE, prefix, true);
    hn_name = src(prefix, BOTH_SUFFIX);
 
    fs = strdup(concatenate(dir_name, "/", file_name, NULL));
    ft = strdup(concatenate(dir_name, "/", hn_name, NULL));
    safe_copy(fs, ft);
    free(fs), free(ft);
 
    DB_PUT_FILE_RESOURCE(DBR_HPFC_HOST, prefix, hn_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_NODE, prefix, strdup(hn_name));
    DB_PUT_FILE_RESOURCE(DBR_HPFC_RTINIT, prefix, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_PARAMETERS, prefix, NO_FILE);
}

References BOTH_SUFFIX, concatenate(), db_get_current_workspace_directory(), db_get_file_resource, DB_PUT_FILE_RESOURCE, entity_name, file_name, free(), module, module_local_name(), NO_FILE, pips_debug, prefix, safe_copy(), src, and strdup().

Referenced by hpfc_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_a_special_io_function()

void compile_a_special_io_function

(

entity

module

)

just copied for the host

Parameters

module

odule

Definition at line 469 of file compile.c.

{
    string  file_name, h_name, dir_name, fs, ft;
 
    const char *prefix = module_local_name(module);
    file_name = db_get_file_resource(DBR_SOURCE_FILE, prefix, true);
    dir_name = db_get_current_workspace_directory();
    h_name = src(prefix, HOST_SUFFIX);
 
    fs = strdup(concatenate(dir_name, "/", file_name, NULL));
    ft = strdup(concatenate(dir_name, "/", h_name, NULL));
    safe_copy(fs, ft);
    free(fs);
    free(ft);
 
    DB_PUT_FILE_RESOURCE(DBR_HPFC_HOST, prefix, h_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_NODE, prefix, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_RTINIT, prefix, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_PARAMETERS, prefix, NO_FILE);
}

References concatenate(), db_get_current_workspace_directory(), db_get_file_resource, DB_PUT_FILE_RESOURCE, file_name, free(), HOST_SUFFIX, module, module_local_name(), NO_FILE, prefix, safe_copy(), src, and strdup().

Referenced by hpfc_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_hpf_reduction()

list compile_hpf_reduction	(	list	lr,
		bool	prolog,
		bool	host
	)

of statement

of statement

Parameters

lr	r
prolog	rolog
host	ost

Definition at line 347 of file special_cases.c.

{
    list /* of statement */ ls = NIL;
    MAP(HPFC_REDUCTIONS, r, 
        ls = CONS(STATEMENT, compile_one_reduction(r, prolog, host), ls),
        lr);
    return ls;
}

References compile_one_reduction(), CONS, HPFC_REDUCTIONS, MAP, NIL, and STATEMENT.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_reduction()

bool compile_reduction	(	statement	initial,
		statement *	phost,
		statement *	pnode
	)

bool compile_reduction(initial, phost, pnode)

true is the compiler succeeded in compiling the reduction that way. ??? many conditions are not yet checked...

Parameters

initial	nitial
phost	host
pnode	node

Definition at line 148 of file special_cases.c.

{
    instruction i = statement_instruction(initial);
    list args = NIL;
    expression ref, cll;
    call reduction;
    t_reduction *red ;
    basic b;
    int dim = 0, arraynum = -1;
    list largs = NIL;
    entity array, hostfunction, nodefunction;
 
    pips_assert("assignment",
                (instruction_call_p(i) && 
                 ENTITY_ASSIGN_P(call_function(instruction_call(i))) &&
                 (gen_length(call_arguments(instruction_call(i)))==2)));
 
    args = call_arguments(instruction_call(i));
    ref  = EXPRESSION(CAR(args));
    cll  = EXPRESSION(CAR(CDR(args)));
 
    pips_assert("reference", (syntax_reference_p(expression_syntax(ref)) &&
            syntax_call_p(expression_syntax(cll))));
 
    reduction = syntax_call(expression_syntax(cll));
    
    pips_debug(7, "call to %s\n", entity_name(call_function(reduction)));
 
    pips_assert("reduction call", call_reduction_p(reduction));
 
    reduction_parameters(reduction, &red, &b, &dim, &array, &largs);
 
    /*
     * the array must be distributed accross the processors, not replicated,
     * and the reference variable mustn't be distributed.
     */
 
    if (!array_distributed_p(array) || 
        (array_distributed_p
         (reference_variable(syntax_reference(expression_syntax(ref))))))
        return(false);
 
    arraynum = load_hpf_number(array);
 
    hostfunction = make_reduction_function("H", dim, red->kind, b, 0);
    nodefunction = make_reduction_function("N", dim, red->kind, b, 4*dim+2);
 
    *phost = make_assign_statement( copy_expression(ref),
                                   make_call_expression(hostfunction, NIL));
    *pnode = 
        make_assign_statement
            ( copy_expression(ref),
             make_call_expression
             (nodefunction,
              CONS(EXPRESSION, entity_to_expression(array),
              CONS(EXPRESSION, int_to_expression(arraynum),
                   gen_nconc(array_lower_upper_bounds_list(array),
                             largs)))));
    
    return(true);
}

References array, array_distributed_p(), array_lower_upper_bounds_list(), call_arguments, call_function, call_reduction_p(), CAR, CDR, CONS, copy_expression(), ENTITY_ASSIGN_P, entity_name, entity_to_expression(), EXPRESSION, expression_syntax, gen_length(), gen_nconc(), instruction_call, instruction_call_p, int_to_expression(), t_reduction::kind, load_hpf_number(), make_assign_statement(), make_call_expression(), make_reduction_function(), NIL, pips_assert, pips_debug, reduction_parameters(), ref, reference_variable, statement_instruction, syntax_call, syntax_call_p, syntax_reference, and syntax_reference_p.

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

complementary_range()

range complementary_range	(	entity	array,
		int	dim,
		range	r
	)

range complementary_range(array, dim, r)

just to avoid a gcc warning

Parameters

array	rray
dim	im

Definition at line 141 of file message-utils.c.

{
    entity newarray = load_new_node(array);
    dimension d = FindIthDimension(newarray, dim);
    int rlo = HpfcExpressionToInt(range_lower(r)),
        rup = HpfcExpressionToInt(range_upper(r)),
        rin = HpfcExpressionToInt(range_increment(r)),
        dlo = HpfcExpressionToInt(dimension_lower(d)),
        dup = HpfcExpressionToInt(dimension_upper(d));
 
    assert(rin==1);
 
    if (dup==rup)
        return(make_range(int_to_expression(dlo),
                          int_to_expression(rlo-1),
                          int_to_expression(1)));
 
    if (dlo==rlo)
        return(make_range(int_to_expression(rup+1),
                          int_to_expression(dup),
                          int_to_expression(1)));
 
    pips_internal_error("well, there is a problem here around");
 
    return(range_undefined); /* just to avoid a gcc warning */
}

References array, assert, dimension_lower, dimension_upper, FindIthDimension(), HpfcExpressionToInt(), int_to_expression(), load_new_node(), make_range(), pips_internal_error, range_increment, range_lower, range_undefined, and range_upper.

Referenced by atomize_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_entity_to_declaration_constraints()

Psysteme compute_entity_to_declaration_constraints	(	entity	ent,
		string	suffix,
		string	prefix
	)

Psysteme compute_entity_to_constraints(ent, suffix, prefix) entity ent: variable the constraints of which are computed strings suffix and prefix: to be used in the dummy variables created.

---

DECLARATION CONSTRAINTS GENERATION

computes the constraints due to the declarations. ! usefull

system may be empty for scalars ???

now the dummy is to be used to generate two inequalities: -dummy + lower <= 0 and dummy - upper <= 0

Parameters

ent	nt
suffix	uffix
prefix	refix

Definition at line 220 of file build-system.c.

{
    list dims = variable_dimensions(type_variable(entity_type(ent)));
    int dim_number = 1;
    Psysteme new_system = sc_new();
    
    pips_assert("variable", entity_variable_p(ent));
    
    /* system may be empty for scalars ???
     */
    pips_debug(5, "entity %s, [%s,%s]\n", entity_name(ent), prefix, suffix);
    
    MAP(DIMENSION, dim,
     {
         entity dummy = get_ith_dummy(prefix, suffix, dim_number);
         int ilower;
         int iupper;
         bool blower = hpfc_integer_constant_expression_p
             (dimension_lower(dim), &ilower);
         bool bupper = hpfc_integer_constant_expression_p
             (dimension_upper(dim), &iupper);
 
         pips_assert("extent known", blower && bupper);
         
         /* now the dummy is to be used to generate two inequalities: 
          * -dummy + lower <= 0 and dummy - upper <= 0
          */
         sc_add_inegalite
             (new_system,
              contrainte_make(vect_make(VECTEUR_NUL,
                                        dummy,  VALUE_MONE,
                                        TCST,   int_to_value(ilower))));
         sc_add_inegalite
             (new_system,
              contrainte_make(vect_make(VECTEUR_NUL,
                                        dummy,  VALUE_ONE,
                                        TCST,   int_to_value(-iupper))));
         dim_number++;
     },
         dims);
    
    sc_creer_base(new_system);
    return new_system;
}

References contrainte_make(), DIMENSION, dimension_lower, dimension_upper, entity_name, entity_type, entity_variable_p, get_ith_dummy(), hpfc_integer_constant_expression_p(), int_to_value, MAP, pips_assert, pips_debug, prefix, sc_add_inegalite(), sc_creer_base(), sc_new(), TCST, type_variable, VALUE_MONE, VALUE_ONE, variable_dimensions, vect_make(), and VECTEUR_NUL.

Referenced by hpfc_compute_entity_to_declaration_constraints().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_receive_content()

list compute_receive_content	(	entity	array,
		list	lr,
		Pvecteur	v
	)

shared!

Parameters

array	rray
lr	r

Definition at line 268 of file message-utils.c.

{
    list content = NIL, l = lr;
    int i = 1;
 
    assert(NumberOfDimension(array)==(int)gen_length(lr));
 
    for (; l; i++, POP(l))
    {
        int procdim = 0;
        bool distributed_dim = ith_dim_distributed_p(array, i, &procdim);
        Value vn = distributed_dim? 
            vect_coeff((Variable) (intptr_t)procdim, v): VALUE_ZERO;
        int neighbour = VALUE_TO_INT(vn);
        range r = RANGE(CAR(l));
 
        if (neighbour!=0)
        {
            entity newarray = load_new_node(array);
            dimension nadim = FindIthDimension(newarray, i);
            expression incr  = range_increment(r);
            int lom1  = HpfcExpressionToInt(dimension_lower(nadim))-1,
                upp1  = HpfcExpressionToInt(dimension_upper(nadim))+1,
                width = (HpfcExpressionToInt(range_upper(r)) -
                         HpfcExpressionToInt(range_lower(r)));
 
            content =
                gen_nconc(content,
                          CONS(RANGE,
                               (neighbour<0)?
                               make_range(int_to_expression(upp1),
                                          int_to_expression(upp1+width),
                                          incr):
                               make_range(int_to_expression(lom1-width),
                                          int_to_expression(lom1),
                                          incr),
                               NIL));
        }
        else
        {
            content = gen_nconc(content, CONS(RANGE, r, NIL)); /* shared! */
        }                               
    }
 
    return(content);
}

References array, assert, CAR, CONS, dimension_lower, dimension_upper, FindIthDimension(), gen_length(), gen_nconc(), HpfcExpressionToInt(), int_to_expression(), intptr_t, ith_dim_distributed_p(), load_new_node(), make_range(), NIL, NumberOfDimension(), POP, RANGE, range_increment, range_lower, range_upper, VALUE_TO_INT, VALUE_ZERO, and vect_coeff().

Referenced by one_receive_message().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_receive_domain()

list compute_receive_domain	(	list	lr,
		Pvecteur	v
	)

shared!

Parameters

lr

r

Definition at line 318 of file message-utils.c.

{
    list l = lr, domain = NIL;
    int i = 1;
    
    for ( ; l!=NIL ; i++, l=CDR(l))
    {
        range r = RANGE(CAR(l));
        Value vn = vect_coeff((Variable) (intptr_t)i, v);
        int neighbour = VALUE_TO_INT(vn);
 
        if (neighbour==0)
            domain = gen_nconc(domain, CONS(RANGE, r, NIL)); /* shared! */
        else
        {
            int lo = HpfcExpressionToInt(range_lower(r)),
                up = HpfcExpressionToInt(range_upper(r));
 
            domain = 
                gen_nconc(domain, 
                          CONS(RANGE, 
                               make_range(int_to_expression(lo+neighbour),
                                          int_to_expression(up+neighbour),
                                          range_increment(r)), 
                               NIL));
        }           
    }
    
    return(domain);
}

References CAR, CDR, CONS, gen_nconc(), HpfcExpressionToInt(), int_to_expression(), intptr_t, make_range(), NIL, RANGE, range_increment, range_lower, range_upper, VALUE_TO_INT, and vect_coeff().

Referenced by one_receive_message().

Here is the call graph for this function:

Here is the caller graph for this function:

conformant_templates_p()

bool conformant_templates_p	(	entity	t1,
		entity	t2
	)

Parameters

t1	1
t2	2

Definition at line 405 of file dynamic.c.

{
    if (t1==t2) 
        return true;
    else if (!conformant_entities_p(t1, t2))
        return false;
    else
        return same_distribute_p
            (load_hpf_distribution(t1), load_hpf_distribution(t2));
}

References conformant_entities_p(), load_hpf_distribution(), and same_distribute_p().

Referenced by align_check(), and same_align_p().

Here is the call graph for this function:

Here is the caller graph for this function:

create_common_parameters_h()

void create_common_parameters_h

(

FILE *

file

)

inits.c

inits.c

in this file there are functions to generate the run-time resolution parameters.

Parameters

file

ile

Definition at line 36 of file inits.c.

{
    fprintf(file,
            "      integer\n"
            "     $     REALNBOFARRAYS,\n"
            "     $     REALNBOFTEMPLATES,\n"
            "     $     REALNBOFPROCESSORS,\n"
            "     $     REALMAXSIZEOFPROCS,\n"
            "     $     REALMAXSIZEOFBUFFER\n\n"
            "!\n! parameters\n!\n"
            "      parameter(REALNBOFARRAYS = %d)\n"
            "      parameter(REALNBOFTEMPLATES = %d)\n"
            "      parameter(REALNBOFPROCESSORS = %d)\n"
            "      parameter(REALMAXSIZEOFPROCS = %d)\n"
            "      parameter(REALMAXSIZEOFBUFFER = %d)\n",
            number_of_distributed_arrays(),
            number_of_templates(),
            number_of_processors(),
            max_size_of_processors(),
            get_int_property("HPFC_BUFFER_SIZE"));
}

References fprintf(), get_int_property(), max_size_of_processors(), number_of_distributed_arrays(), number_of_processors(), and number_of_templates().

Referenced by put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param()

void create_init_common_param

(

FILE *

file

)

create_init_common_param (templates and modules)

Parameters

file

ile

Definition at line 511 of file inits.c.

{
    create_init_common_param_for_templates(file);
    create_init_common_param_for_processors(file);
}

References create_init_common_param_for_processors(), and create_init_common_param_for_templates().

Referenced by put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param_for_arrays()

void create_init_common_param_for_arrays	(	FILE *	file,
		entity	module
	)

NODIMA: Number Of DIMensions of an Array ATOT: Array TO Template

The primary entity is the initial mapping ??? not sure... some decision should be involved...

RANGEA: lower, upper, size and declaration, aso

RANGEA contents:

1: lower bound 2: upper bound 3: size, (2)-(1)+1 4: new declaration flag

5: distribution parameter n, 6: alignment rate a, 7: alignment shift, b-t_{m}

5: distribution parameter n, 6: cycle length n*p, 7: initial cycle number, 8: alignment shift, b-t_{m}

5: distribution parameter n 6: cycle length n*p, 7: initial cycle number, 8: alignment shift, b-t_{m} 9: alignment rate a, 10: chunck size ceil(n,|a|)

ALIGN

Parameters

file	ile
module	odule

Definition at line 158 of file inits.c.

{
    list l = list_of_distributed_arrays_for_module(module);
    
    fprintf(file, "!\n! Arrays Initializations for %s\n!\n",
            module_local_name(module));
 
    MAP(ENTITY, array,
    {
        int an = load_hpf_number(array);
        int nd = NumberOfDimension(array);
        align al = load_hpf_alignment(array);
        entity template = align_template(al);
        int tn = load_hpf_number(template);
        distribute di = load_hpf_distribution(template);
        int i;
        
        /* NODIMA: Number Of  DIMensions of an Array
         * ATOT: Array TO Template
         */
        fprintf(file, 
                "!\n! initializing array %s, number %d\n!\n"
                "      NODIMA(%d) = %d\n"
                "      ATOT(%d) = %d\n",
                entity_local_name(array), an, an, nd, an, tn);
 
        if (dynamic_entity_p(array) && array==load_primary_entity(array))
        {
            /* The primary entity is the initial mapping ???
             * not sure... some decision should be involved...
             */
            fprintf(file, "\n"
                    "      MSTATUS(%d) = %d\n"
                    "      LIVEMAPPING(%d) = .TRUE.\n", an, an, an);
        }
        
        /* RANGEA: lower, upper, size and declaration, aso
         */
        i = 1;
        for (i=1; i<=nd; i++)
        {
            dimension d = entity_ith_dimension(array, i);
            int lb = HpfcExpressionToInt(dimension_lower(d));
            int ub = HpfcExpressionToInt(dimension_upper(d));
            int sz = (ub-lb+1);
            tag decl = new_declaration_tag(array, i);
            alignment a = FindAlignmentOfDim(align_alignment(al), i);
            
            /* RANGEA contents:
             *
             * 1: lower bound
             * 2: upper bound
             * 3: size, (2)-(1)+1
             * 4: new declaration flag
             */
            fprintf(file, "\n"
                    "      RANGEA(%d, %d, 1) = %d\n"
                    "      RANGEA(%d, %d, 2) = %d\n"
                    "      RANGEA(%d, %d, 3) = %d\n!\n"
                    "      RANGEA(%d, %d, 4) = %d\n", 
                    an, i, lb, an, i, ub, an, i, sz,
                    an, i, code_number(decl));
            
            switch(decl)
            {
             case is_hpf_newdecl_none:
                 break;
             case is_hpf_newdecl_alpha:
                 /*
                  * 5: 1 - lower bound
                  */
                 fprintf(file, "      RANGEA(%d, %d, 5) = %d\n", 
                         an, i, (1-lb));
                 break;
             case is_hpf_newdecl_beta:
             {
                 int tdim = alignment_templatedim(a);
                 int procdim = 0;
                 distribution
                     d = FindDistributionOfDim(distribute_distribution(di), 
                                               tdim,
                                               &procdim);
                 int param = HpfcExpressionToInt(distribution_parameter(d));
                 int rate;
                 int shift;
                 dimension 
                     dim = FindIthDimension(template, tdim);
                 
                 pips_assert("block distribution",
                             style_block_p(distribution_style(d)));
                 
                 rate = HpfcExpressionToInt(alignment_rate(a));
                 shift = (HpfcExpressionToInt(alignment_constant(a)) -
                          HpfcExpressionToInt(dimension_lower(dim)));
 
                 /* 5: distribution parameter n, 
                  * 6: alignment rate a,
                  * 7: alignment shift, b-t_{m}
                  */
                 fprintf(file, 
                         "      RANGEA(%d, %d, 5) = %d\n"
                         "      RANGEA(%d, %d, 6) = %d\n"
                         "      RANGEA(%d, %d, 7) = %d\n",
                         an, i, param, an, i, rate, an, i, shift);
                 
                 break;
             }
             case is_hpf_newdecl_gamma:
             {
                 int tdim = alignment_templatedim(a);
                 int procdim = 0;
                 distribution
                     d = FindDistributionOfDim(distribute_distribution(di), 
                                               tdim,
                                               &procdim);
                 int param = HpfcExpressionToInt(distribution_parameter(d));
                 int sc;
                 int no;
                 int shift;
                 dimension 
                     dim = FindIthDimension(template, tdim);
                 entity
                     proc = distribute_processors(di);
                 
                 pips_assert("cyclic distribution",
                             style_cyclic_p(distribution_style(d)));
                 
                 sc = param*SizeOfIthDimension(proc, procdim);
                 shift = (HpfcExpressionToInt(alignment_constant(a)) -
                          HpfcExpressionToInt(dimension_lower(dim)));
                 no = (lb + shift) / sc ;
                 
                 /* 5: distribution parameter n,
                  * 6: cycle length n*p,
                  * 7: initial cycle number,
                  * 8: alignment shift, b-t_{m}
                  */
                 fprintf(file,
                         "      RANGEA(%d, %d, 5) = %d\n"
                         "      RANGEA(%d, %d, 6) = %d\n"
                         "      RANGEA(%d, %d, 7) = %d\n"
                         "      RANGEA(%d, %d, 8) = %d\n", 
                         an, i, param, an, i, sc, an, i, no, an, i, shift);
                 
                 break;
             }
             case is_hpf_newdecl_delta:
             {
                 int tdim = alignment_templatedim(a);
                 int procdim = 0;
                 distribution
                     d = FindDistributionOfDim(distribute_distribution(di), 
                                               tdim,
                                               &procdim);
                 int rate = HpfcExpressionToInt(alignment_rate(a));
                 int cst  = HpfcExpressionToInt(alignment_constant(a));
                 int param = HpfcExpressionToInt(distribution_parameter(d));
                 int sc;
                 int no;
                 int shift;
                 int chck;                    
                 dimension 
                     templdim = FindIthDimension(template, tdim);
                 entity
                     proc = distribute_processors(di);
                 
                 pips_assert("cyclic distribution",
                             style_cyclic_p(distribution_style(d)));
                 
                 sc = param*SizeOfIthDimension(proc, procdim);
                 shift = (cst - HpfcExpressionToInt(dimension_lower(templdim)));
                 no = (rate*lb + shift) / sc ;
                 chck = iceil(param, abs(rate));
                 
                 /*  5: distribution parameter n
                  *  6: cycle length n*p,
                  *  7: initial cycle number,
                  *  8: alignment shift, b-t_{m}
                  *  9: alignment rate a,
                  * 10: chunck size ceil(n,|a|)
                  */
                 fprintf(file,
                         "      RANGEA(%d, %d, 5) = %d\n"
                         "      RANGEA(%d, %d, 6) = %d\n"
                         "      RANGEA(%d, %d, 7) = %d\n"
                         "      RANGEA(%d, %d, 8) = %d\n"
                         "      RANGEA(%d, %d, 9) = %d\n"
                         "      RANGEA(%d, %d, 10) = %d\n",
                         an, i, param, an, i, sc, an, i, no,
                         an, i, shift, an, i, rate, an, i, chck);
                 break;
             }
             default:
                 pips_internal_error("unexpected decl. tag (%d)", decl);
             }
         }
 
         fprintf(file, "\n");
 
         /* ALIGN
          */
 
         for(i=1 ; i<=NumberOfDimension(template) ; i++)
         {
             alignment
                 a = FindAlignmentOfTemplateDim(align_alignment(al), i);
 
              if (a==alignment_undefined)
              {
                  fprintf(file, "      ALIGN(%d, %d, 1) = INTFLAG\n", an, i);
              }
             else
             {
                 int adim = alignment_arraydim(a);
 
                 fprintf(file, 
                         "      ALIGN(%d, %d, 1) = %d\n"
                         "      ALIGN(%d, %d, 2) = %d\n"
                         "      ALIGN(%d, %d, 3) = %d\n", 
                         an, i, adim, an, i,
                         adim ? HpfcExpressionToInt(alignment_rate(a)) : 0,
                         an, i, HpfcExpressionToInt(alignment_constant(a)));
 
             }
          }
     },
         l);
 
    gen_free_list(l);
}

References abs, align_alignment, align_template, alignment_arraydim, alignment_constant, alignment_rate, alignment_templatedim, alignment_undefined, array, code_number(), dimension_lower, dimension_upper, distribute_distribution, distribute_processors, distribution_parameter, distribution_style, dynamic_entity_p, ENTITY, entity_ith_dimension(), entity_local_name(), FindAlignmentOfDim(), FindAlignmentOfTemplateDim(), FindDistributionOfDim(), FindIthDimension(), fprintf(), gen_free_list(), HpfcExpressionToInt(), iceil, is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, list_of_distributed_arrays_for_module(), load_hpf_alignment(), load_hpf_distribution(), load_hpf_number(), load_primary_entity(), MAP, module, module_local_name(), new_declaration_tag(), NumberOfDimension(), pips_assert, pips_internal_error, SizeOfIthDimension(), style_block_p, and style_cyclic_p.

Referenced by put_generated_resources_for_common(), and put_generated_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param_for_processors()

void create_init_common_param_for_processors

(

FILE *

file

)

NODIMP: Number Of DIMensions of a Processors arrangement

RANGEP: lower, upper, size

Parameters

file

ile

Definition at line 470 of file inits.c.

{
    fprintf(file, "!\n! Processors Initializations\n!\n");
 
    MAP(ENTITY, proc,
    {
        int pn = load_hpf_number(proc);
        int nd  = NumberOfDimension(proc);
        int procdim = 1;
         
         fprintf(file, "!\n! initializing processors %s, number %d\n!\n",
                 entity_local_name(proc), pn);
 
         /* NODIMP: Number Of  DIMensions of a Processors arrangement
          */
         fprintf(file, "      NODIMP(%d) = %d\n", pn, nd);
         
         /* RANGEP: lower, upper, size 
          */
         MAP(DIMENSION, d,
         {
              int lb = HpfcExpressionToInt(dimension_lower(d));
              int ub = HpfcExpressionToInt(dimension_upper(d));
              int sz = (ub-lb+1);
 
              fprintf(file, "\n"
                      "      RANGEP(%d, %d, 1) = %d\n"
                      "      RANGEP(%d, %d, 2) = %d\n"
                      "      RANGEP(%d, %d, 3) = %d\n",
                      pn, procdim, lb, pn, procdim, ub, pn, procdim, sz);
              
              procdim++;
          },
              variable_dimensions(type_variable(entity_type(proc))));
     },
         list_of_processors());
}

References DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_local_name(), entity_type, fprintf(), HpfcExpressionToInt(), list_of_processors(), load_hpf_number(), MAP, NumberOfDimension(), type_variable, and variable_dimensions.

Referenced by create_init_common_param().

Here is the call graph for this function:

Here is the caller graph for this function:

create_init_common_param_for_templates()

void create_init_common_param_for_templates

(

FILE *

file

)

NODIMT: Number Of DIMensions of a Template TTOP: Template TO Processors arrangement

RANGET: lower, upper, size

DIST

Parameters

file

ile

Definition at line 391 of file inits.c.

{
    fprintf(file, "!\n! Templates Initializations\n!\n");
 
    MAP(ENTITY, template,
    {
         int tn = load_hpf_number(template);
         int nd  = NumberOfDimension(template);
         distribute di = load_hpf_distribution(template);
         entity proc = distribute_processors(di);
         int pn = load_hpf_number(proc);
         int procdim = 1;
         int tempdim = 1;
         
         /* NODIMT: Number Of  DIMensions of a Template
          * TTOP: Template TO Processors arrangement
          */
         fprintf(file,
                 "!\n! initializing template %s, number %d\n!\n"
                 "      NODIMT(%d) = %d\n"
                 "      TTOP(%d) = %d\n", 
                 entity_local_name(template), tn, tn, nd, tn, pn);
         
         /* RANGET: lower, upper, size 
          */
         MAP(DIMENSION, d,
         {
             int lb = HpfcExpressionToInt(dimension_lower(d));
             int ub = HpfcExpressionToInt(dimension_upper(d));
             int sz = (ub-lb+1);
             
              fprintf(file, "\n"
                      "      RANGET(%d, %d, 1) = %d\n"
                      "      RANGET(%d, %d, 2) = %d\n"
                      "      RANGET(%d, %d, 3) = %d\n",
                      tn, tempdim, lb, tn, tempdim, ub, tn, tempdim, sz);
 
              tempdim++;
          },
              variable_dimensions(type_variable(entity_type(template))));
 
         /* DIST
          */
         tempdim = 1;
         fprintf(file, "\n");
         MAP(DISTRIBUTION, d,
         {
              int param;
              bool block_case = false;
 
              switch(style_tag(distribution_style(d)))
              {
              case is_style_none:
                  break;
              case is_style_block:
                  block_case = true;
                  _FALLTHROUGH_;
              case is_style_cyclic:
                  param = HpfcExpressionToInt(distribution_parameter(d));
                  if (!block_case) param = -param;
                  fprintf(file, 
                          "      DIST(%d, %d, 1) = %d\n"
                          "      DIST(%d, %d, 2) = %d\n", 
                          tn, procdim, tempdim, tn, procdim, param);
                  procdim++;
                  break;
              default:
                  pips_internal_error("unexpected style tag");
                  break;
              }
 
              tempdim++;
          },
              distribute_distribution(di));
     },
         list_of_templates());
}

References _FALLTHROUGH_, DIMENSION, dimension_lower, dimension_upper, distribute_distribution, distribute_processors, DISTRIBUTION, distribution_parameter, distribution_style, ENTITY, entity_local_name(), entity_type, fprintf(), HpfcExpressionToInt(), is_style_block, is_style_cyclic, is_style_none, list_of_templates(), load_hpf_distribution(), load_hpf_number(), MAP, NumberOfDimension(), pips_internal_error, style_tag, type_variable, and variable_dimensions.

Referenced by create_init_common_param().

Here is the call graph for this function:

Here is the caller graph for this function:

create_parameters_h()

void create_parameters_h	(	FILE *	file,
		entity	module
	)

create_parameters_h

to be called after the declaration_with_overlaps() call. it generates the parameters for module.

formal parameters are passed the value by the caller as far as overlapable dimensions are concerned.

otherwise it is a secondary copy

Parameters

file	ile
module	odule

Definition at line 65 of file inits.c.

{
    entity newarray = entity_undefined;
    int i;
    list l = list_of_distributed_arrays_for_module(module);
 
    fprintf(file, "!\n! parameters generated for %s\n!\n",
            module_local_name(module));
 
    MAP(ENTITY, array,
    {
        bool is_argument = storage_formal_p(entity_storage(array));
        int andim;
        newarray = load_new_node(array);
        andim  = NumberOfDimension(newarray);
 
        pips_debug(8, "considering array %s (new is %s)\n",
                   entity_name(array), entity_name(newarray));
 
        /* formal parameters are passed the value by the caller
         * as far as overlapable dimensions are concerned.
         */
        if (!dynamic_entity_p(array) || !bound_similar_mapping_p(array) ||
            (bound_similar_mapping_p(array) &&
             array==load_similar_mapping(array)))
            for (i=1 ; i<=andim ; i++)
            {
                if (!is_argument || !ith_dim_overlapable_p(array, i))
                {
                    string ld = bound_parameter_name(newarray, LOWER, i);
                    string ud = bound_parameter_name(newarray, UPPER, i);
                    dimension d = FindIthDimension(newarray, i);
                    
                    fprintf(file,
                            "      integer \n"
                            "     $    %s,\n"
                            "     $    %s\n" 
                            "      parameter(%s = %d)\n"
                            "      parameter(%s = %d)\n",
                            ld, ud, 
                            ld, HpfcExpressionToInt(dimension_lower(d)),
                            ud, HpfcExpressionToInt(dimension_upper(d)));
 
                    free(ld); free(ud);
                }
            }
        /* otherwise it is a secondary copy */
    },
        l);
 
    gen_free_list(l);
}

References array, bound_parameter_name(), bound_similar_mapping_p(), dimension_lower, dimension_upper, dynamic_entity_p, ENTITY, entity_name, entity_storage, entity_undefined, FindIthDimension(), fprintf(), free(), gen_free_list(), HpfcExpressionToInt(), ith_dim_overlapable_p(), list_of_distributed_arrays_for_module(), load_new_node(), load_similar_mapping(), LOWER, MAP, module, module_local_name(), NumberOfDimension(), pips_debug, storage_formal_p, ud(), and UPPER.

Referenced by put_generated_resources_for_common(), and put_generated_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_host_node_variables()

void debug_host_node_variables

(

entity

e

)

HPFC module by Fabien COELHO.

HOST AND NODE ENTITIES MANAGEMENT

Definition at line 44 of file host_node_entities.c.

{
    fprintf(stderr, "variable %s:\n\tnh=%s\n\toh=%s\n\tnn=%s\n\ton=%s\n",
            entity_name(e),
            bound_new_host_p(e)? entity_name(load_new_host(e)): "<undef>",
            bound_old_host_p(e)? entity_name(load_old_host(e)): "<undef>",
            bound_new_node_p(e)? entity_name(load_new_node(e)): "<undef>",
            bound_old_node_p(e)? entity_name(load_old_node(e)): "<undef>");
}

References bound_new_host_p(), bound_new_node_p(), bound_old_host_p(), bound_old_node_p(), entity_name, fprintf(), load_new_host(), load_new_node(), load_old_host(), and load_old_node().

Here is the call graph for this function:

debug_print_referenced_entities()

void debug_print_referenced_entities

(

void *

obj

)

Parameters

obj

bj

Definition at line 906 of file compile.c.

{
    gen_multi_recurse(obj, reference_domain, gen_true, debug_ref_rwt, NULL);
}

References debug_ref_rwt(), gen_multi_recurse(), gen_true(), and reference_domain.

Referenced by update_common_references_in_obj().

Here is the call graph for this function:

Here is the caller graph for this function:

declaration_delayed_p()

bool declaration_delayed_p

(

entity

)

declaration_with_overlaps_for_module()

void declaration_with_overlaps_for_module

(

entity

module

)

Parameters

module

odule

Definition at line 835 of file declarations.c.

{
    list l = list_of_distributed_arrays_for_module(module);
    declaration_with_overlaps(l);
    gen_free_list(l);
}

References deal_with_similars(), declaration_with_overlaps(), gen_free_list(), list_of_distributed_arrays_for_module(), and module.

Referenced by compile_common(), and compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

define_node_processor_id()

statement define_node_processor_id	(	entity	proc,
		entity(*)(int)	creation
	)

generate-util.c

generate-util.c

of expression

of statement

Parameters

proc

roc

Definition at line 49 of file generate-util.c.

{
    int i, procn = load_hpf_number(proc);
    list /* of expression */ mypos_indices,
         /* of statement */  ls = NIL;
    reference mypos;
    entity dummy;
 
    for(i=NumberOfDimension(proc); i>0; i--)
    {
        dummy = creation(i);
        mypos_indices = CONS(EXPRESSION, int_to_expression(i),
                        CONS(EXPRESSION, int_to_expression(procn), 
                             NIL));
        mypos = make_reference(hpfc_name_to_entity(MYPOS), mypos_indices);
        ls = CONS(STATEMENT,
                  make_assign_statement(entity_to_expression(dummy),
                                        reference_to_expression(mypos)),
                  ls);
    }
                                       
    return make_block_statement(ls);
}

References CONS, entity_to_expression(), EXPRESSION, hpfc_name_to_entity(), int_to_expression(), load_hpf_number(), make_assign_statement(), make_block_statement(), make_reference(), MYPOS, NIL, NumberOfDimension(), reference_to_expression(), and STATEMENT.

Referenced by GENERATION(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_dynamic_hpf()

entities delete_dynamic_hpf

(

entity

)

delete_entity_update_common()

void delete_entity_update_common

(

entity

)

delete_hpf_alignment()

align delete_hpf_alignment

(

entity

)

delete_hpf_distribution()

distribute delete_hpf_distribution

(

entity

)

delete_hpf_number()

intptr_t delete_hpf_number

(

entity

)

delete_hpf_reductions()

entities delete_hpf_reductions

(

statement

)

delete_maybeuseful_mappings()

entities delete_maybeuseful_mappings

(

statement

)

delete_new_host()

entity delete_new_host

(

entity

)

delete_new_node()

entity delete_new_node

(

entity

)

delete_old_host()

entity delete_old_host

(

entity

)

delete_old_node()

entity delete_old_node

(

entity

)

delete_overlap_status()

list delete_overlap_status

(

entity

)

delete_primary_entity()

entity delete_primary_entity

(

entity

)

delete_renamings()

list delete_renamings

(

statement

)

delete_similar_mapping()

entity delete_similar_mapping

(

entity

)

delete_statement_only_io()

void delete_statement_only_io

(

statement

)

DistArraysEffects()

list DistArraysEffects

(

expression

expr

)

effects' action in an expression are here supposed to be read one's but that may not be correct?

Parameters

expr

xpr

Definition at line 241 of file hpfc-util.c.

{
    list le = proper_effects_of_expression(expr), lde = NIL;
 
    FOREACH(EFFECT, e, le) {
      if(store_effect_p(e)) {
        if (array_distributed_p(effect_variable(e)))
          lde=CONS(EFFECT,e,lde);
      }
    }
 
    gen_free_list(le);
    return(lde);
}

References array_distributed_p(), CONS, EFFECT, effect_variable, FOREACH, gen_free_list(), NIL, proper_effects_of_expression(), and store_effect_p().

Referenced by written_effects_to_dist_arrays_p().

Here is the call graph for this function:

Here is the caller graph for this function:

DistributionParameterOfArrayDim()

int DistributionParameterOfArrayDim	(	entity	array,
		int	dim,
		int *	pprocdim
	)

Parameters

array	rray
dim	im
pprocdim	procdim

Definition at line 472 of file hpfc-util.c.

{
    entity template = array_to_template(array);
    distribute d = load_hpf_distribution(template);
    distribution
        di = FindDistributionOfDim
            (distribute_distribution(d),
             alignment_templatedim(FindArrayDimAlignmentOfArray(array, dim)),
             pprocdim);
    
    return HpfcExpressionToInt(distribution_parameter(di));
}

References alignment_templatedim, array, array_to_template, distribute_distribution, distribution_parameter, FindArrayDimAlignmentOfArray, FindDistributionOfDim(), HpfcExpressionToInt(), and load_hpf_distribution().

Referenced by generate_one_message(), message_manageable_p(), shape_one_message(), and template_cell_local_mapping().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_current_remapping_graph()

void dump_current_remapping_graph

(

string

when

)

Parameters

when

hen

Definition at line 1440 of file dynamic.c.

{
    dump_remapping_graph(when, list_of_remapping_statements());
}

References dump_remapping_graph(), and list_of_remapping_statements().

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

dup_list_of_Pvecteur()

list dup_list_of_Pvecteur

(

list

l

)

??? the complexity of this function could be improved greatly...

Definition at line 93 of file message-utils.c.

{
    list result = NIL;
 
    MAPL(cv,
     {
         Pvecteur v = (Pvecteur) PVECTOR(CAR(cv));
         result = gen_nconc(result, CONS(PVECTOR, (VECTOR) vect_dup(v), NIL));
     },
         l);
 
    return result;
}

References CAR, CONS, gen_nconc(), MAPL, NIL, PVECTOR, vect_dup(), and VECTOR.

Referenced by atomize_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

dup_list_of_ranges_list()

list dup_list_of_ranges_list

(

list

l

)

??? the complexity of this function could be greatly improved

Definition at line 72 of file message-utils.c.

{
    list result = NIL;
 
    MAPL(cc,
     {
         list lr = CONSP(CAR(cc));
         list lrp = NIL;
         MAP(RANGE, r, lrp = gen_nconc(lrp, CONS(RANGE, r, NIL)), lr);
         assert(gen_length(lrp)==gen_length(lr));
         result = gen_nconc(result, CONS(LIST, lrp, NIL));
     },
         l);
 
    assert(gen_length(l)==gen_length(result));
    return result;
}

References assert, CAR, CONS, CONSP, gen_length(), gen_nconc(), LIST, MAP, MAPL, NIL, and RANGE.

Referenced by atomize_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

dynamic_hpf_undefined_p()

bool dynamic_hpf_undefined_p

(

void

)

dynamic.c

empty_range_p()

bool empty_range_p

(

range

r

)

if we cannot decide, the range is supposed not to be empty

Definition at line 203 of file message-utils.c.

{
    int lo, up;
 
    /*   if we cannot decide, the range is supposed not to be empty
     */
    if (! (hpfc_integer_constant_expression_p(range_lower(r), &lo) &&
           hpfc_integer_constant_expression_p(range_upper(r), &up)))
        return false; 
    else
        return lo>up;
}

References hpfc_integer_constant_expression_p(), range_lower, and range_upper.

Referenced by empty_section_p().

Here is the call graph for this function:

Here is the caller graph for this function:

empty_section_p()

bool empty_section_p

(

list

lr

)

Parameters

lr

r

Definition at line 195 of file message-utils.c.

{
    return((ENDP(lr))?
           (false):
           (empty_range_p(RANGE(CAR(lr))) || empty_section_p(CDR(lr))));
}

References CAR, CDR, empty_range_p(), empty_section_p(), ENDP, and RANGE.

Referenced by empty_section_p(), keep_non_empty_domain_messages(), and keep_non_empty_messages_with_destination().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_hpf_number()

expression entity_hpf_number

(

entity

e

)

returns the hpf_number parameter as a string not really needed ??? ??? never called

Definition at line 196 of file declarations.c.

{
    storage
        s = entity_storage(e);
    bool
        in_common = entity_in_common_p(e),
        in_ram = storage_ram_p(s);
    ram 
        r = (in_ram ? storage_ram(s) : ram_undefined);
        const char* suffix = entity_local_name(e),
        *prefix = 
            (in_ram ? 
             entity_local_name(in_common ? ram_section(r) : ram_function(r)) :
             "DEFAULT");
 
    pips_assert("ram variable", entity_variable_p(e) && in_ram);
 
    return(MakeCharacterConstantExpression
           (strdup(concatenate("n_", prefix, "_", suffix, NULL))));
                           
}

References concatenate(), entity_in_common_p(), entity_local_name(), entity_storage, entity_variable_p, MakeCharacterConstantExpression(), pips_assert, prefix, ram_function, ram_section, ram_undefined, storage_ram, storage_ram_p, and strdup().

Here is the call graph for this function:

entity_hpfc_dummy_p()

bool entity_hpfc_dummy_p

(

entity

e

)

build-system.c

build-system.c

• array dimensions (PHIs)
• template dimensions
• processor dimensions
• cycles and offsets
• local array dimensions
• indexes and others coming thru the regions

Inequations to be defined

• array declaration
• template declaration
• processors arrangement declaration
• local offsets within a block
• local declarations
• regions accessed by the statement

Equations to be defined

• alignement
• distribution
• local <-> global?
• processor linearization?

Remarks

• offset to be computed
• access functions are not needed (hidden by regions)
• how to be sure that something can be done?
• will newgen structures be necessary to build the systems?
• will I have to remove some variables (indexes ?)
• one equation to be added for replicated dimensions. variable names:

ALPHA{1-7}: array dimensions, THETA{1-7}: template dimensions, PSI{1-7}: processor dimensions, SIGMA{1-7}: auxiliary variable, GAMMA{1-7}: cycles, DELTA{1-7}: local offsets, LALPHA{1-7}: local array dimensions, if specified...

plus "PRIME" versions

---

HPF CONSTRAINTS GENERATION

Definition at line 106 of file build-system.c.

{
  return same_string_p(entity_module_name(e), HPFC_PACKAGE);
}

References entity_module_name(), HPFC_PACKAGE, and same_string_p.

Referenced by put_variables_in_ordered_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_loop_index_p()

bool entity_loop_index_p

(

entity

e

)

Definition at line 383 of file compiler-util.c.

{
    MAP(LOOP, l, if (e == loop_index(l)) return true, current_loop_list);
    return false;
}

References current_loop_list, LOOP, loop_index, and MAP.

Referenced by affine_expression_of_loop_index_p(), shift_expression_of_loop_index_p(), and simple_indices_p().

Here is the caller graph for this function:

entity_processor_p()

bool entity_processor_p

(

entity

)

entity_template_p()

bool entity_template_p

(

entity

)

Referenced by alive_arrays(), continue_propagation_p(), entity_to_hpf_distribute_constraints(), extract_the_align(), extract_the_distribute(), hpfc_compute_distribute_constraints(), and one_distribute_directive().

Here is the caller graph for this function:

entity_to_declaration_constraints()

Psysteme entity_to_declaration_constraints	(	entity	e,
		tag	what
	)

gives back the constraints due to the declarations.

Uses a demand driven approach: computed systems are stored in the declaration_constraints mapping for later search.

Parameters

what

hat

Definition at line 285 of file build-system.c.

{
    Psysteme p = load_entity_declaration_constraints(e+what);
    pips_assert("variable", entity_variable_p(e));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_entity_to_declaration_constraints(e, what);
        store_entity_declaration_constraints(e+what, p);
    }
 
    DEBUG_SYST(9, concatenate("entity ", entity_name(e), NULL), p);
 
    return p;
}

References concatenate(), DEBUG_SYST, entity_name, entity_variable_p, hpfc_compute_entity_to_declaration_constraints(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_shared_io_system(), generate_system_for_distributed_variable(), GENERATION(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_hpf_align_constraints()

Psysteme entity_to_hpf_align_constraints

(

entity

e

)

Definition at line 480 of file build-system.c.

{
    Psysteme p = load_entity_hpf_align_constraints(e);
 
    pips_assert("distributed variable", array_distributed_p(e));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_align_constraints(e);
        store_entity_hpf_align_constraints(e, p);
    }
 
    return p;
}

References array_distributed_p(), hpfc_compute_align_constraints(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_system_for_distributed_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_hpf_distribute_constraints()

Psysteme entity_to_hpf_distribute_constraints

(

entity

e

)

Definition at line 495 of file build-system.c.

{
    Psysteme p = load_entity_hpf_distribute_constraints(e);
 
    pips_assert("template", entity_template_p(e));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_distribute_constraints(e);
        store_entity_hpf_distribute_constraints(e, p);
    }
 
    return p;
}

References entity_template_p(), hpfc_compute_distribute_constraints(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_system_for_distributed_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_new_declaration()

Psysteme entity_to_new_declaration

(

entity

array

)

Parameters

array

rray

Definition at line 732 of file build-system.c.

{
    Psysteme p = load_entity_new_declaration_constraints(array);
 
    pips_assert("distributed array", array_distributed_p(array));
 
    if (Psysteme_undefined_p(p))
    {
        p = hpfc_compute_entity_to_new_declaration(array);
        store_entity_new_declaration_constraints(array, p);
    }
 
    return p;
}

References array, array_distributed_p(), hpfc_compute_entity_to_new_declaration(), pips_assert, and Psysteme_undefined_p.

Referenced by generate_system_for_distributed_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_region()

effect entity_to_region	(	statement	stat,
		entity	ent,
		tag	act
	)

effect entity_to_region(stat, ent, act) statement stat; entity ent; tag act;

gives the region of ent with action act in statement stat.

Parameters

stat	tat
ent	nt
act	ct

Definition at line 515 of file build-system.c.

{
    list l = load_statement_local_regions(stat);
 
    MAP(EFFECT, e,
        if ((reference_variable(effect_any_reference(e))==ent) &&
            ((int) action_tag(effect_action(e))==act)) return(e),
        l);
 
    return(effect_undefined);
}

References action_tag, EFFECT, effect_action, effect_any_reference, effect_undefined, load_statement_local_regions(), MAP, and reference_variable.

Referenced by generate_distributed_io_system(), and generate_shared_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_update_common_undefined_p()

bool entity_update_common_undefined_p

(

entity

)

error_reset_dynamic_hpf()

void error_reset_dynamic_hpf

(

void

)

error_reset_hpf_alignment()

void error_reset_hpf_alignment

(

void

)

error_reset_hpf_distribution()

void error_reset_hpf_distribution

(

void

)

error_reset_hpf_number()

void error_reset_hpf_number

(

void

)

error_reset_hpf_reductions()

void error_reset_hpf_reductions

(

void

)

error_reset_hpfc_current_statement()

void error_reset_hpfc_current_statement

(

void

)

error_reset_maybeuseful_mappings()

void error_reset_maybeuseful_mappings

(

void

)

error_reset_new_host()

void error_reset_new_host

(

void

)

error_reset_new_node()

void error_reset_new_node

(

void

)

error_reset_old_host()

void error_reset_old_host

(

void

)

error_reset_old_node()

void error_reset_old_node

(

void

)

error_reset_overlap_status()

void error_reset_overlap_status

(

void

)

error_reset_primary_entity()

void error_reset_primary_entity

(

void

)

error_reset_renamings()

void error_reset_renamings

(

void

)

error_reset_similar_mapping()

void error_reset_similar_mapping

(

void

)

error_reset_the_dynamics()

void error_reset_the_dynamics

(

void

)

expr_compute_local_index()

expression expr_compute_local_index	(	entity	array,
		int	dim,
		expression	expr
	)

new index computation formula, derived from the new declarations made for the given dimension.

just to avoid a gcc warning

Parameters

array	rray
dim	im
expr	xpr

Definition at line 198 of file run-time.c.

{
    if (get_bool_property("HPFC_EXPAND_COMPUTE_LOCAL_INDEX"))
    {
        tag newdecl = new_declaration_tag(array, dim);
        dimension the_dim = entity_ith_dimension(array, dim);
        
        switch(newdecl)
        {
        case is_hpf_newdecl_none:
            return(expr);
        case is_hpf_newdecl_alpha:
        {
            int dl = HpfcExpressionToInt(dimension_lower(the_dim));
            expression shift = int_to_expression(1 - dl);
            
            return(MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME), 
                                  expr, shift));
        }
        case is_hpf_newdecl_beta:
        {
            align a = load_hpf_alignment(array);
            entity template = align_template(a);
            distribute d = load_hpf_distribution(template);
            alignment al = FindAlignmentOfDim(align_alignment(a), dim);
            int tempdim = alignment_templatedim(al), procdim;
            dimension template_dim = FindIthDimension(template,tempdim);
            distribution
                di = FindDistributionOfDim(distribute_distribution(d), 
                                           tempdim, 
                                           &procdim);
            expression
                parameter = distribution_parameter(di),
                rate = alignment_rate(al),
                prod, t1, the_mod, t2;
            int
                iabsrate = abs(HpfcExpressionToInt(rate)),
                ishift = (HpfcExpressionToInt(alignment_constant(al)) - 
                          HpfcExpressionToInt(dimension_lower(template_dim)));
            
            
            prod = 
                ((HpfcExpressionToInt(rate)==1)?
                 (expr):
                 ((iabsrate==1)?
                  (MakeUnaryCall(entity_intrinsic(UNARY_MINUS_OPERATOR_NAME),
                                 expr)):
                  (MakeBinaryCall(entity_intrinsic(MULTIPLY_OPERATOR_NAME),
                                  rate,
                                  expr))));
            
            t1 = ((ishift==0)?
                  (prod):
                  ((ishift>0)?
                   (MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME),prod,
                                   int_to_expression(ishift))):
                   (MakeBinaryCall(entity_intrinsic(MINUS_OPERATOR_NAME),prod,
                                   int_to_expression(abs(ishift))))));
            
            the_mod = MakeBinaryCall(entity_intrinsic(MOD_INTRINSIC_NAME),
                                     t1,
                                     parameter);
            
            t2 = ((iabsrate==1)?
                  (the_mod):
                  MakeBinaryCall(entity_intrinsic(DIVIDE_OPERATOR_NAME),
                                 the_mod,
                                 int_to_expression(iabsrate)));
            
            return(MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME), 
                              t2,
                                  int_to_expression(1)));
        }
        case is_hpf_newdecl_gamma:
        {
            expression
                expr1 = 
                    int_to_expression(load_hpf_number(array)),
                    expr2 = int_to_expression(dim);
            
            return(MakeTernaryCall(hpfc_name_to_entity(LOCAL_IND_GAMMA), 
                                       expr1, expr2, expr));
        }
        case is_hpf_newdecl_delta:
        {
            expression
                expr1 = int_to_expression(load_hpf_number(array)),
                expr2 = int_to_expression(dim);
            
            return(MakeTernaryCall(hpfc_name_to_entity(LOCAL_IND_DELTA), 
                                       expr1, expr2, expr));
        }
        default:
            pips_internal_error("unexpected new declaration tag");
        }
        
    }
    else
    {
        expression
            expr1 = int_to_expression(load_hpf_number(array)),
            expr2 = int_to_expression(dim);
        
        return(MakeTernaryCall(hpfc_name_to_entity(LOCAL_IND), 
                                   expr1, expr2, expr));
    }
 
    return(expression_undefined); /* just to avoid a gcc warning */
}

References abs, align_alignment, align_template, alignment_constant, alignment_rate, alignment_templatedim, array, dimension_lower, distribute_distribution, distribution_parameter, DIVIDE_OPERATOR_NAME, entity_intrinsic(), entity_ith_dimension(), expression_undefined, FindAlignmentOfDim(), FindDistributionOfDim(), FindIthDimension(), get_bool_property(), hpfc_name_to_entity(), HpfcExpressionToInt(), int_to_expression(), is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, load_hpf_alignment(), load_hpf_distribution(), load_hpf_number(), LOCAL_IND, LOCAL_IND_DELTA, LOCAL_IND_GAMMA, MakeBinaryCall(), MakeTernaryCall(), MakeUnaryCall(), MINUS_OPERATOR_NAME, MOD_INTRINSIC_NAME, MULTIPLY_OPERATOR_NAME, new_declaration_tag(), pips_internal_error, PLUS_OPERATOR_NAME, and UNARY_MINUS_OPERATOR_NAME.

Referenced by st_compute_ith_local_index().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_lattice()

void extract_lattice	(	Psysteme	s,
		list	scanners,
		list *	newscs,
		list *	ddc
	)

lattice_extraction.c

lattice_extraction.c

what: extracts a lattice from a set of equalities how: Hermite form computation on equalities implying scanners

• equalities translated in F and M;
• variables = scanners (s) + others (o) + cst (1)
• F.s + M.o + V == 0
• H = PFQ; // I assert P==I, maybe optimistic for this implementation...
• (1) s = Q.y
• (2) H.y + M.o + V == 0 then
• (2) => new equalities that define some y(r)
• (1) => ddc in some order..., plus replacement in inequalities
• (1) => newscs, but what about the order?

input: Psysteme and scanners output: modified system, new scanners and deducibles side effects:

• may create some new variables bugs or features: old deduction

• should try to remove deducibles before hand?

of entity

void implementation: nothing done!

else do the job

FM (so) + V == 0

Fs + Mo + V == 0

H = P * F * Q

H = (Hl 0)

and memory leak, by the way

Hli = Hl^-1

Q = (Ql Qr)

QlHli = Ql * Hl^-1

QlHliM = QlHli * M

QlHliV = QlHli * V

I

mQr = - Qr

create nscanners-neq new scanning variables... they are the yr's.

We have: mQr yr + I s + QlHliM o + QlHliV == 0 yr are the new scanners, s the old ones, deducable from the new ones. the equation must also be used to remove s from the inequalities.

Fnew = ( mQr I QlHliM )

Now we have: (a) Fnew (yr s o)^t + QlHliV == 0 (b) lns – the new scanners

we must (1) generate deducables from (a), (2) regenerate inequalities on yr's.

clean the new system

old scanners are deduced now:

Parameters

scanners	the system is modified of entity
newscs	variables to be scanned of entity
ddc	returned new scanners of expression

Definition at line 113 of file lattice_extraction.c.

{
    /* - should try to remove deducibles before hand?
     */
    int nscanners, nothers, ntotal, neq;
    Pbase b, bsorted, byr;
    Pmatrix FM, F, M, V, P, H, Q, Hl, Hli, Ql, Qr, QlHli,
      QlHliM, QlHliV, mQr, I, Fnew;
    Value det_P, det_Q;
    int i;
    list /* of entity */ lns = NIL, ltmp = NIL;
    Pcontrainte eq;
 
    neq = sc_nbre_egalites(s);
 
    if (neq==0 || !get_bool_property("HPFC_EXTRACT_LATTICE")) {
      /* void implementation: nothing done!
       */
      *newscs = gen_copy_seq(scanners);
      *ddc = NIL;
      return;
    }
    /* else do the job */
 
    DEBUG_SYST(3, "initial system", s);
    DEBUG_ELST(3, "scanners", scanners);
 
    b = sc_base(s);
    nscanners = gen_length(scanners);
    ntotal = base_dimension(b);
    nothers = ntotal - nscanners;
 
    message_assert("more scanners than equalities", nscanners>=neq);
 
    bsorted = scanners_then_others(b, scanners);
 
    DEBUG_BASE(3, "sorted base", bsorted);
    pips_debug(3, "%d scanners, %d others, %d eqs\n", nscanners, nothers, neq);
 
    /* FM (so) + V == 0 */
    FM = matrix_new(neq, ntotal);
    V  = matrix_new(neq, 1);
 
    constraints_to_matrices(sc_egalites(s), bsorted, FM, V);
 
    DEBUG_MTRX(4, "FM", FM);
    DEBUG_MTRX(4, "V", V);
 
    /* Fs + Mo + V == 0 */
    F = matrix_new(neq, nscanners);
    M = matrix_new(neq, nothers);
 
    ordinary_sub_matrix(FM, F, 1, neq, 1, nscanners);
    ordinary_sub_matrix(FM, M, 1, neq, nscanners+1, ntotal);
 
    matrix_free(FM);
 
    DEBUG_MTRX(4, "F", F);
    DEBUG_MTRX(4, "M", M);
 
    /* H = P * F * Q */
    H = matrix_new(neq, nscanners);
    P = matrix_new(neq, neq);
    Q = matrix_new(nscanners, nscanners);
 
    matrix_hermite(F, P, H, Q, &det_P, &det_Q);
 
    DEBUG_MTRX(4, "H", H);
    DEBUG_MTRX(4, "P", P);
    DEBUG_MTRX(4, "Q", Q);
 
    message_assert("P == I", matrix_diagonal_p(P) && det_P==1);
 
    /* H = (Hl 0) */
    Hl = matrix_new(neq, neq);
    ordinary_sub_matrix(H, Hl, 1, neq, 1, neq);
    matrix_free(H);
 
    DEBUG_MTRX(4, "Hl", Hl);
 
    if (!matrix_triangular_unimodular_p(Hl, true)) {
      pips_user_warning("fast exit, some yes/no lattice skipped\n");
      /* and memory leak, by the way */
      *newscs = gen_copy_seq(scanners);
      *ddc = NIL;
      return;
    }
 
    message_assert("Hl is lower triangular unimodular",
                   matrix_triangular_unimodular_p(Hl, true));
 
    /* Hli = Hl^-1 */
    Hli = matrix_new(neq, neq);
    matrix_unimodular_triangular_inversion(Hl, Hli, true);
    matrix_free(Hl);
 
    DEBUG_MTRX(4, "Hli", Hli);
 
    /* Q = (Ql Qr) */
    Ql = matrix_new(nscanners, neq);
    Qr = matrix_new(nscanners, nscanners-neq);
 
    ordinary_sub_matrix(Q, Ql, 1, nscanners, 1, neq);
    ordinary_sub_matrix(Q, Qr, 1, nscanners, neq+1, nscanners);
 
    DEBUG_MTRX(4, "Ql", Ql);
    DEBUG_MTRX(4, "Qr", Qr);
 
    matrix_free(Q);
 
    /* QlHli = Ql * Hl^-1 */
    QlHli = matrix_new(nscanners, neq);
    matrix_multiply(Ql, Hli, QlHli);
 
    matrix_free(Ql);
    matrix_free(Hli);
 
    /* QlHliM = QlHli * M */
    QlHliM = matrix_new(nscanners, nothers);
    matrix_multiply(QlHli, M, QlHliM);
 
    matrix_free(M);
 
    /* QlHliV = QlHli * V */
    QlHliV = matrix_new(nscanners, 1);
    matrix_multiply(QlHli, V, QlHliV);
 
    matrix_free(V);
    matrix_free(QlHli);
 
    /* I */
    I = matrix_new(nscanners, nscanners);
    matrix_identity(I, 0);
 
    /* mQr = - Qr */
    mQr = matrix_new(nscanners, nscanners-neq);
    matrix_uminus(Qr, mQr);
    matrix_free(Qr);
 
    /* create nscanners-neq new scanning variables... they are the yr's.
     */
    for (i=0; i<nscanners-neq; i++)
      lns = CONS(ENTITY,
                 hpfc_new_variable(node_module, MakeBasic(is_basic_int)), lns);
 
    byr = list_to_base(lns);
    bsorted = append_to(byr, bsorted); byr = BASE_NULLE;
 
    /* We have: mQr yr + I s + QlHliM o + QlHliV == 0
     * yr are the new scanners, s the old ones, deducable from the new ones.
     * the equation must also be used to remove s from the inequalities.
     *
     * Fnew = ( mQr I QlHliM )
     */
    Fnew = matrix_new(nscanners, 2*nscanners-neq+nothers);
 
    insert_sub_matrix(Fnew, mQr, 1, nscanners, 1, nscanners-neq);
    insert_sub_matrix(Fnew, I, 1, nscanners, nscanners-neq+1, 2*nscanners-neq);
    insert_sub_matrix(Fnew, QlHliM, 1, nscanners,
                      2*nscanners-neq+1, 2*nscanners-neq+nothers);
 
    matrix_free(I);
    matrix_free(mQr);
    matrix_free(QlHliM);
 
    /* Now we have:
     *   (a) Fnew (yr s o)^t + QlHliV == 0
     *   (b) lns -- the new scanners
     *
     * we must
     *  (1) generate deducables from (a),
     *  (2) regenerate inequalities on yr's.
     */
 
    matrices_to_constraints(&eq, bsorted, Fnew, QlHliV);
    matrix_free(Fnew);
    matrix_free(QlHliV);
 
    /* clean the new system
     */
    contraintes_free(sc_egalites(s));
    sc_egalites(s) = eq;
    base_rm(sc_base(s));
    sc_creer_base(s);
 
    /* old scanners are deduced now:
     */
    *ddc = gen_append(*ddc, simplify_deducable_variables(s, scanners, &ltmp));
    pips_assert("no vars left", ENDP(ltmp));
 
    *newscs = lns;
 
    base_rm(bsorted);
 
    DEBUG_SYST(3, "resulting system", s);
    DEBUG_ELST(3, "new scanners", lns);
}

References append_to(), base_dimension, BASE_NULLE, base_rm, CONS, constraints_to_matrices(), contraintes_free(), DEBUG_BASE, DEBUG_ELST, DEBUG_MTRX, DEBUG_SYST, ENDP, ENTITY, eq, F, gen_append(), gen_copy_seq(), gen_length(), get_bool_property(), hpfc_new_variable(), insert_sub_matrix(), is_basic_int, list_to_base(), MakeBasic(), matrices_to_constraints(), matrix_diagonal_p(), matrix_free, matrix_hermite(), matrix_identity(), matrix_multiply(), matrix_new(), matrix_triangular_unimodular_p(), matrix_uminus(), matrix_unimodular_triangular_inversion(), message_assert, NIL, node_module, ordinary_sub_matrix(), pips_assert, pips_debug, pips_user_warning, Q, sc_creer_base(), scanners_then_others(), and simplify_deducable_variables().

Referenced by hpf_remapping().

Here is the call graph for this function:

Here is the caller graph for this function:

FindAlignmentOfDim()

alignment FindAlignmentOfDim	(	list	lal,
		int	dim
	)

Parameters

lal	al
dim	im

Definition at line 377 of file hpfc-util.c.

{
    list l=lal;
 
    while ((!ENDP(l)) && (alignment_arraydim(ALIGNMENT(CAR(l))) != dim))
        POP(l);
 
    return (l==NIL) ? alignment_undefined : ALIGNMENT(CAR(l));
}

References ALIGNMENT, alignment_arraydim, alignment_undefined, CAR, ENDP, NIL, and POP.

Referenced by ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), expr_compute_local_index(), ith_dim_distributed_p(), ith_dim_overlapable_p(), and template_dimension_of_array_dimension().

Here is the caller graph for this function:

FindAlignmentOfTemplateDim()

alignment FindAlignmentOfTemplateDim	(	list	lal,
		int	dim
	)

Parameters

lal	al
dim	im

Definition at line 389 of file hpfc-util.c.

{
    list l=lal;
 
    while ((!ENDP(l)) && (alignment_templatedim(ALIGNMENT(CAR(l))) != dim))
        POP(l);
 
    return ((l==NULL)?(alignment_undefined):(ALIGNMENT(CAR(l))));
}

References ALIGNMENT, alignment_templatedim, alignment_undefined, CAR, ENDP, and POP.

Referenced by array_distribution_similar_p(), array_ranges_to_template_ranges(), create_init_common_param_for_arrays(), get_alignment(), hpfc_compute_align_constraints(), hpfc_compute_unicity_constraints(), and processors_dim_replicated_p().

Here is the caller graph for this function:

FindDefinitionsOf()

list FindDefinitionsOf	(	statement	stat,
		list	lsyn
	)

Parameters

stat	tat
lsyn	syn

Definition at line 239 of file compiler-util.c.

{
    list result = NIL;
 
    pips_assert("empty lists", ENDP(syntax_list) && ENDP(found_definitions));
 
    syntax_list = lsyn;
 
    gen_recurse(stat,
                statement_domain,
                gen_true,
                FindDefinitionsOf_rewrite);
 
    result = found_definitions,
    syntax_list = NIL,
    found_definitions = NIL;
 
    return(result);
}

References ENDP, FindDefinitionsOf_rewrite(), found_definitions, gen_recurse, gen_true(), NIL, pips_assert, statement_domain, and syntax_list.

Referenced by hpf_compile_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

FindDistributionOfDim()

distribution FindDistributionOfDim	(	list	ldi,
		int	dim,
		int *	pdim
	)

Parameters

ldi	di
dim	im
pdim	dim

Definition at line 401 of file hpfc-util.c.

{
    list l = ldi;
    int i, procdim = 1;
 
    pips_assert("valid dimension", dim>=1 && dim<=(int)gen_length(ldi));
 
    for (i=1; i<dim; i++) 
    {
        if (!style_none_p(distribution_style(DISTRIBUTION(CAR(l)))))
            procdim++;
        POP(l);
    }
 
    (*pdim) = procdim;
    return(DISTRIBUTION(CAR(l)));
}

References CAR, DISTRIBUTION, distribution_style, gen_length(), pips_assert, POP, and style_none_p.

Referenced by ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), DistributionParameterOfArrayDim(), expr_compute_local_index(), get_distribution(), ith_dim_distributed_p(), ith_dim_overlapable_p(), and processor_number().

Here is the call graph for this function:

Here is the caller graph for this function:

FindDistributionOfProcessorDim()

distribution FindDistributionOfProcessorDim	(	list	ldi,
		int	dim,
		int *	tdim
	)

Parameters

ldi	di
dim	im
tdim	dim

Definition at line 421 of file hpfc-util.c.

{
    int i = 1, procdim = 0;
    
    MAP(DISTRIBUTION, d,
    {
        if (!style_none_p(distribution_style(d)))
            procdim++;
        
        if (procdim==dim)
        {
            (*tdim) = i;
            return(d);
        }
        
        i++;
    },
        ldi);
 
    pips_internal_error("dimension %d not found", dim);
 
    return(distribution_undefined);
}    

References DISTRIBUTION, distribution_style, distribution_undefined, MAP, pips_internal_error, and style_none_p.

Referenced by array_distribution_similar_p(), hpfc_compute_distribute_constraints(), processors_dim_replicated_p(), and template_ranges_to_processors_ranges().

Here is the caller graph for this function:

FindRefToDistArray()

list FindRefToDistArray

(

void *

obj

)

Parameters

obj

bj

Definition at line 282 of file hpfc-util.c.

{
    list result = NIL, saved = found_syntaxes;
    found_syntaxes = NIL;
    gen_multi_recurse(obj,
                      syntax_domain,
                      gen_true,
                      FindRefToDistArray_syntax_rewrite, NULL);
 
    result = found_syntaxes, found_syntaxes = saved;
 
    return result;
}

References FindRefToDistArray_syntax_rewrite(), found_syntaxes, gen_multi_recurse(), gen_true(), NIL, and syntax_domain.

Referenced by FindRefToDistArrayFromList(), FindRefToDistArrayInStatement_call_filter(), FindRefToDistArrayInStatement_expression_filter(), generate_c1_alpha(), and ref_to_dist_array_p().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArrayFromList()

list FindRefToDistArrayFromList

(

list

lexpr

)

FindRefToDistArrayFromList.

these functions compute the list of syntax that are references to a distributed variable.

Parameters

lexpr

expr

Definition at line 262 of file hpfc-util.c.

{
    list l=NIL;
    MAP(EXPRESSION, e,{l=gen_nconc(FindRefToDistArray(e),l);},lexpr);
    return(l);
}

References EXPRESSION, FindRefToDistArray(), gen_nconc(), MAP, and NIL.

Referenced by generate_c1_beta().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArrayInStatement()

void FindRefToDistArrayInStatement	(	statement	obj,
		list *	lwp,
		list *	lrp
	)

Parameters

obj	bj
lwp	wp
lrp	rp

Definition at line 121 of file compiler-util.c.

{
    list
        saved_r = found_read,
        saved_w = found_written;
 
    found_read = NIL, found_written = NIL;
 
    gen_multi_recurse(obj,
                      call_domain,
                      FindRefToDistArrayInStatement_call_filter,
                      gen_null,
                      expression_domain,
                      FindRefToDistArrayInStatement_expression_filter,
                      gen_null,
                      NULL);
 
    *lwp = found_written, *lrp = found_read,
    found_read = saved_r, found_written = saved_w;
}

References call_domain, expression_domain, FindRefToDistArrayInStatement_call_filter(), FindRefToDistArrayInStatement_expression_filter(), found_read, found_written, gen_multi_recurse(), gen_null(), and NIL.

Referenced by hpf_compile_parallel_body(), hpf_compile_parallel_loop(), and Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

fortran_library_entity_p()

bool fortran_library_entity_p

(

entity

e

)

else not found

Definition at line 52 of file local-ri-util.c.

{
    string *s; const char* name=entity_local_name(e);
 
    if (!top_level_entity_p(e)) return(false);
    for (s=fortran_library; *s!=(string) NULL; s++)
        if (same_string_p(*s, name)) return true;
 
    return false; /* else not found */
}

References entity_local_name(), fortran_library, same_string_p, and top_level_entity_p().

Referenced by hpfc_compile(), and hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_lmessage()

void fprint_lmessage	(	FILE *	file,
		list	l
	)

Parameters

file

ile

Definition at line 231 of file debug-util.c.

{
    if (ENDP(l))
        fprintf(file, "message list is empty\n");
    else
        MAP(MESSAGE, m, fprint_message(file, m), l);
}

References ENDP, fprint_message(), fprintf(), MAP, and MESSAGE.

Referenced by messages_handling().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_lrange()

void fprint_lrange	(	FILE *	file,
		list	l
	)

Parameters

file

ile

Definition at line 200 of file debug-util.c.

{
    bool firstrange = true;
 
    MAP(RANGE, r,
     {
         if (!firstrange)
             (void) fprintf(file, ", ");
 
         firstrange = false;
         fprint_range(file, r);
     },
        l);
}

References fprint_range(), fprintf(), MAP, and RANGE.

Referenced by fprint_message().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_message()

void fprint_message	(	FILE *	file,
		message	m
	)

Parameters

file

ile

Definition at line 217 of file debug-util.c.

{
    (void) fprintf(file, "message is array %s(", 
                   entity_local_name(message_array(m)));
    fprint_lrange(file, message_content(m));
    (void) fprintf(file, ")\nto\n");
    vect_fprint(file, (Pvecteur) message_neighbour(m), variable_dump_name);
    (void) fprintf(file, "domain is ");
    fprint_lrange(file, message_dom(m));
    (void) fprintf(file, "\n");
}

References entity_local_name(), fprint_lrange(), fprintf(), message_array, message_content, message_dom, message_neighbour, variable_dump_name(), and vect_fprint().

Referenced by atomize_one_message(), and fprint_lmessage().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_range()

void fprint_range	(	FILE *	file,
		range	r
	)

Parameters

file

ile

Definition at line 176 of file debug-util.c.

{
    int lo, up, in;
    bool
        blo = hpfc_integer_constant_expression_p(range_lower(r), &lo),
        bup = hpfc_integer_constant_expression_p(range_upper(r), &up),
        bin = hpfc_integer_constant_expression_p(range_increment(r), &in);
 
    if (blo && bup && bin)
    {
        if (in==1)
            if (lo==up)
                fprintf(file, "%d", lo);
            else
                fprintf(file, "%d:%d", lo, up);
        else
            fprintf(file, "%d:%d:%d", lo, up, in);
    }
    else
        fprintf(file, "X");
}

References fprintf(), hpfc_integer_constant_expression_p(), range_increment, range_lower, and range_upper.

Referenced by fprint_lrange().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hpf_object_lists()

void free_hpf_object_lists

(

void

)

Definition at line 98 of file declarations.c.

{
    gen_free_list(distributed_arrays),
    gen_free_list(templates),
    gen_free_list(processors);
 
    reset_hpf_object_lists();
}

References gen_free_list(), and reset_hpf_object_lists().

Referenced by close_data_status().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hpfc_current_mappings()

void free_hpfc_current_mappings

(

void

)

Definition at line 200 of file build-system.c.

{
    free_declaration_constraints_map();
    free_hpf_align_constraints_map();
    free_hpf_distribute_constraints_map();
    free_new_declaration_constraints_map();
}

Referenced by reset_resources_for_module().

Here is the caller graph for this function:

free_only_io_map()

void free_only_io_map

(

void

)

Referenced by reset_resources_for_module().

Here is the caller graph for this function:

free_update_common_map()

void free_update_common_map

(

void

)

Referenced by hpfc_directives_handler().

Here is the caller graph for this function:

free_vector_list()

void free_vector_list

(

list

l

)

Definition at line 382 of file special_cases.c.

{
    gen_map((gen_iter_func_t)vect_rm, l);
    gen_free_list(l);
}

References gen_free_list(), gen_map(), and vect_rm().

Referenced by generate_subarray_shift(), subarray_shift_assignment_p(), and subarray_shift_p().

Here is the call graph for this function:

Here is the caller graph for this function:

full_copy_p()

bool full_copy_p	(	statement	s,
		reference *	pleft,
		reference *	pright
	)

of lists

of loops

of expressions

the loop nest must be perfect... !!! should check for continues?

the body must be a simple assignment

compatible arities

number of enclosing loops

the lhs should be fully defined by the loop nest... but it does not matter for the rhs!

both lhs and rhs references must be aligned

??? should check the new declarations...

Parameters

pleft	left
pright	right

Definition at line 869 of file special_cases.c.

{
    list /* of lists */ lb = NIL, l,
         /* of loops */ ll = NIL,
         /* of expressions */ la = NIL;
    statement body = parallel_loop_nest_to_body(s, &lb, &ll), simple;
    expression e;
    reference left, right;
    int len;
 
    DEBUG_STAT(6, "considering statement", s);
 
    /* the loop nest must be perfect... !!!
     * should check for continues?
     */
    for (l=lb; l; POP(l)) 
        if (number_of_non_empty_statements(CONSP(CAR(l)))>1) 
            {
                XDEBUG("non perfectly nested");
                gen_free_list(lb), gen_free_list(ll); return false;
            }
 
    gen_free_list(lb), lb = NIL;
 
    /* the body must be a simple assignment
     */
    simple = simple_statement(body);
 
    if (!simple || !instruction_assign_p(statement_instruction(simple)))
    { 
        XDEBUG("body not simple"); gen_free_list(ll); return false;
    }
 
    la = call_arguments(instruction_call(statement_instruction(simple)));
    pips_assert("2 arguments to assign", gen_length(la)==2);
 
    left = expression_reference(EXPRESSION(CAR(la)));
    e = EXPRESSION(CAR(CDR(la)));
 
    if (!expression_reference_p(e))
    {
        XDEBUG("rhs not a reference"); gen_free_list(ll); return false;
    }
 
    right = expression_reference(e);
 
    /* compatible arities 
     */
    len = (int) gen_length(ll); /* number of enclosing loops */
 
    if ((int) gen_length(reference_indices(left))!=len ||
        (int) gen_length(reference_indices(right))!=len)
    {
        XDEBUG("incompatible arities"); gen_free_list(ll); return false;
    }
 
    /* the lhs should be fully defined by the loop nest...
     * but it does not matter for the rhs!
     */
    if (!full_define_p(left, ll))
    {
        XDEBUG("lhs not fully defined"); gen_free_list(ll); return false;
    }
 
    gen_free_list(ll); 
 
    /* both lhs and rhs references must be aligned
     */
    if (!references_aligned_p(left, right))
    {
        XDEBUG("references not aligned"); return false;
    }
 
    /* ??? should check the new declarations...
     */
 
    XDEBUG("ok");
    *pleft = left;
    *pright = right;
    return true;
}

References call_arguments, CAR, CDR, CONSP, DEBUG_STAT, EXPRESSION, expression_reference(), expression_reference_p(), full_define_p(), gen_free_list(), gen_length(), instruction_assign_p(), instruction_call, int, NIL, number_of_non_empty_statements(), parallel_loop_nest_to_body(), pips_assert, POP, reference_indices, references_aligned_p(), simple, simple_statement(), statement_instruction, and XDEBUG.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

full_define_p()

bool full_define_p	(	reference	r,
		list	ll
	)

of expression

of dimension

of entity

checks that the indices are simply the loop indexes, and that the whole dimension is scanned. Also avoids (i,i)...

checks that the loop range scans the whole dimension

increment must be 1. lowers and uppers must be equal.

Parameters

ll

l

Definition at line 771 of file special_cases.c.

{
    entity array = reference_variable(r);
    list /* of expression */ li = reference_indices(r),
         /* of dimension */ ld,
         /* of entity */ lseen = NIL;
    int ndim;
    
    pips_assert("variable", entity_variable_p(array));
 
    ld = variable_dimensions(type_variable(entity_type(array)));
    pips_assert("same arity", gen_length(ll)==gen_length(ld));
 
    /* checks that the indices are *simply* the loop indexes,
     * and that the whole dimension is scanned. Also avoids (i,i)...
     */
    for(ndim=1; li; POP(li), POP(ld), ndim++)
    {
        syntax s = expression_syntax(EXPRESSION(CAR(li)));
        entity index;
        dimension dim;
        range rg;
        loop l;
        expression inc;
 
        if (!syntax_reference_p(s)) 
        {
            gen_free_list(lseen);
            return false;
        }
 
        index = reference_variable(syntax_reference(s));
 
        if (gen_in_list_p(index, lseen))
        {
            gen_free_list(lseen);
            return false;
        }
 
        lseen = CONS(ENTITY, index, lseen);
 
        l = find_loop(index, ll);
        
        if (!l) 
        {
            gen_free_list(lseen);
            return false;
        }
 
        /* checks that the loop range scans the whole dimension */
 
        rg = loop_range(l);
        inc = range_increment(rg);
        dim = DIMENSION(CAR(ld));
        
        /* increment must be 1.
         * lowers and uppers must be equal.
         */
        if (!integer_constant_expression_p(inc) ||
            integer_constant_expression_value(inc)!=1 ||
            !same_expression_p(range_lower(rg), dimension_lower(dim)) ||
            !same_expression_p(range_upper(rg), dimension_upper(dim)))
        {
            pips_debug(9, "incomplete scan of %s[dim=%d]\n", 
                       entity_name(array), ndim);
            gen_free_list(lseen);
            return false;
        }
    }
 
    gen_free_list(lseen);
    return true;
}

References array, CAR, CONS, DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_name, entity_type, entity_variable_p, EXPRESSION, expression_syntax, find_loop(), gen_free_list(), gen_in_list_p(), gen_length(), integer_constant_expression_p(), integer_constant_expression_value(), loop_range, NIL, pips_assert, pips_debug, POP, range_increment, range_lower, range_upper, reference_indices, reference_variable, same_expression_p(), syntax_reference, syntax_reference_p, type_variable, and variable_dimensions.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

full_linearization()

Pcontrainte full_linearization	(	entity	obj,
		entity	var,
		int *	psize,
		entity(*)(int)	create_var,
		bool	fortran_way,
		int	initial_offset
	)

remapping.c

remapping.c

var is set to the result. *psize returns the size of obj. Done the Fortran way, or the other way around... initial offset if desired

Parameters

obj	bj
var	array being lin.
psize	assigned variable if desired
create_var	returned array extent
fortran_way	dimension variable builder
initial_offset	Fortran/C linearization way

Definition at line 80 of file remapping.c.

{
    int dim = NumberOfDimension(obj), low, up, size, i;
    Pvecteur v = VECTEUR_NUL;
 
    for(*psize=1, i=fortran_way ? dim : 1 ;
        fortran_way ? i>0 : i<=dim; 
        i+= fortran_way ? -1 : 1)
    {
        get_entity_dimensions(obj, i, &low, &up);
        size = up - low + 1;
        *psize *= size;
        v = vect_multiply(v, int_to_value(size));
        vect_add_elem(&v, (Variable) create_var(i), VALUE_ONE);
        vect_add_elem(&v, TCST, int_to_value(-low));
    }
 
    if (var) vect_add_elem(&v, (Variable) var, VALUE_MONE);
    if (initial_offset) 
        vect_add_elem(&v, TCST, 
                      int_to_value(initial_offset));
 
    return contrainte_make(v);
}

References contrainte_make(), get_entity_dimensions(), int_to_value, NumberOfDimension(), TCST, VALUE_MONE, VALUE_ONE, vect_add_elem(), vect_multiply(), and VECTEUR_NUL.

Referenced by hpfc_broadcast_buffers(), and hpfc_compute_lid().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_all_liveness()

statement generate_all_liveness	(	entity	primary,
		bool	val
	)

Parameters

primary	rimary
val	al

Definition at line 940 of file remapping.c.

{
    return generate_all_liveness_but(primary, val, entity_undefined);
}

References entity_undefined, and generate_all_liveness_but().

Referenced by hpf_compile_call(), and root_statement_remapping_inits().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_c1_alpha()

void generate_c1_alpha	(	statement	stat,
		list *	lhp,
		list *	lnp
	)

generate_c1_alpha

a distributed array variable is defined

read references to distributed arrays.

generation of the code to get the necessary values...

then the updated statement is to be added to node:

Update the values of the defined distributed variable if necessary...

the overall statements are generated.

Parameters

stat	tat
lhp	hp
lnp	np

Definition at line 121 of file generate.c.

{
    statement statcomputation, statcomputecomputer, statifcomputer;
    expression writtenexpr, newreadexpr;
    call the_call;
    list
        lupdatecomp = NIL,
        lupdatenotcomp = NIL,
        lreadreftodistarray = NIL,
        lstatcomp = NIL,
        lstatnotcomp = NIL,
        lstat = NIL,
        linds = NIL;
    reference ref, newref;
    entity newarray;
 
    (*lhp) = NIL;
    (*lnp) = NIL;
 
    pips_assert("call", statement_call_p(stat));
 
    the_call = instruction_call(statement_instruction(stat));
    pips_assert("assignment", ENTITY_ASSIGN_P(call_function(the_call)));
 
    writtenexpr = EXPRESSION(CAR(call_arguments(the_call)));
    pips_assert("reference",
                syntax_reference_p(expression_syntax(writtenexpr)) &&
           (array_distributed_p
            (reference_variable
             (syntax_reference(expression_syntax(writtenexpr))))));
 
    /* read references to distributed arrays.
     */
    lreadreftodistarray =
        FindRefToDistArray(EXPRESSION(CAR(CDR(call_arguments(the_call)))));
 
    /* generation of the code to get the necessary values...
     */
    MAP(SYNTAX, s,
    {
        list lnotcomp;
        list lcomp;
 
        pips_debug(8, "considering reference to %s\n",
              entity_name(reference_variable(syntax_reference(s))));
 
        generate_read_of_ref_for_computer(s, &lcomp, &lnotcomp);
 
        lstatcomp = gen_nconc(lstatcomp, lcomp);
        lstatnotcomp = gen_nconc(lstatnotcomp, lnotcomp);
    },
        lreadreftodistarray);
 
    gen_free_list(lreadreftodistarray);
 
    /* then the updated statement is to be added to node:
     */
    ref = syntax_reference(expression_syntax(writtenexpr));
    newarray  =  load_new_node(reference_variable(ref));
    generate_compute_local_indices(ref, &lstat, &linds);
    newref = make_reference(newarray, linds);
    newreadexpr = UpdateExpressionForModule
        (node_module, EXPRESSION(CAR(CDR(call_arguments(the_call)))));
 
    statcomputation =
        make_assign_statement(reference_to_expression(newref),
                              newreadexpr);
 
    lstatcomp = gen_nconc(lstatcomp, lstat);
    lstatcomp = gen_nconc(lstatcomp, CONS(STATEMENT, statcomputation, NIL));
 
    /* Update the values of the defined distributed variable
     * if necessary...
     */
    generate_update_values_on_nodes(ref, newref, &lupdatecomp, &lupdatenotcomp);
 
    lstatcomp = gen_nconc(lstatcomp, lupdatecomp);
    lstatnotcomp = gen_nconc(lstatnotcomp, lupdatenotcomp);
 
    /* the overall statements are generated.
     */
    statcomputecomputer = st_compute_current_computer(ref);
    statifcomputer = st_make_nice_test(condition_computerp(),
                                       lstatcomp,
                                       lstatnotcomp);
 
    DEBUG_STAT(8, entity_name(node_module), statifcomputer);
 
    (*lnp) = CONS(STATEMENT, statcomputecomputer,
             CONS(STATEMENT, statifcomputer,
                  NIL));
    (*lhp) = NIL;
 
    return;
 }

References array_distributed_p(), call_arguments, call_function, CAR, CDR, condition_computerp, CONS, DEBUG_STAT, ENTITY_ASSIGN_P, entity_name, EXPRESSION, expression_syntax, FindRefToDistArray(), gen_free_list(), gen_nconc(), generate_compute_local_indices(), generate_read_of_ref_for_computer(), generate_update_values_on_nodes(), instruction_call, load_new_node(), make_assign_statement(), make_reference(), MAP, NIL, node_module, pips_assert, pips_debug, ref, reference_to_expression(), reference_variable, st_compute_current_computer(), st_make_nice_test(), STATEMENT, statement_call_p(), statement_instruction, SYNTAX, syntax_reference, syntax_reference_p, and UpdateExpressionForModule().

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_c1_beta()

void generate_c1_beta	(	statement	stat,
		list *	lhp,
		list *	lnp
	)

generate.c

generate.c

these conditions are to be verifyed, by calculating the proper effects of the statement.

to be corrected later on.

this shouldn't be necessary

references to distributed arrays: w(A(I)) = B(I) so the whole list is to be considered.

generation of the code

Parameters

stat	tat
lhp	hp
lnp	np

Definition at line 41 of file generate.c.

{
    statement staths, statns;
    expression w;
    call the_call;
    list lreftodistarray = NIL;
 
    (*lhp) = NIL;
    (*lnp) = NIL;
 
    pips_assert("call", statement_call_p(stat));
 
    the_call = instruction_call(statement_instruction(stat));
 
    /* this shouldn't be necessary
     */
    pips_assert("assignment", ENTITY_ASSIGN_P(call_function(the_call)));
 
    w = EXPRESSION(CAR(call_arguments(the_call)));
 
    pips_assert("reference",
                syntax_reference_p(expression_syntax(w)) &&
            (!array_distributed_p
             (reference_variable(syntax_reference(expression_syntax(w))))));
 
    /* references to distributed arrays:
     * w(A(I)) = B(I)
     * so the whole list is to be considered.
     */
    lreftodistarray = FindRefToDistArrayFromList(call_arguments(the_call));
 
    /* generation of the code
     */
    MAP(SYNTAX, s,
     {
         list lhost;
         list lnode;
 
         pips_debug(8, "considering reference to %s\n",
               entity_name(reference_variable(syntax_reference(s))));
 
         generate_read_of_ref_for_all(s, &lhost, &lnode);
 
         (*lhp) = gen_nconc((*lhp), lhost);
         (*lnp) = gen_nconc((*lnp), lnode);
     },
         lreftodistarray);
 
    /*
     * then updated statements are to be added to both host and nodes:
     */
 
    staths = instruction_to_statement(make_instruction
                          (is_instruction_call,
                           make_call(call_function(the_call),
                                     lUpdateExpr(host_module,
                                                 call_arguments(the_call)))));
 
    statns = instruction_to_statement(make_instruction
                          (is_instruction_call,
                           make_call(call_function(the_call),
                                     lUpdateExpr(node_module,
                                                 call_arguments(the_call)))));
 
    DEBUG_STAT(9, entity_name(host_module), staths);
    DEBUG_STAT(9, entity_name(node_module), statns);
 
    (*lhp) = gen_nconc((*lhp), CONS(STATEMENT, staths, NIL));
    (*lnp) = gen_nconc((*lnp), CONS(STATEMENT, statns, NIL));
 
    gen_free_list(lreftodistarray);
}

References array_distributed_p(), call_arguments, call_function, CAR, CONS, DEBUG_STAT, ENTITY_ASSIGN_P, entity_name, EXPRESSION, expression_syntax, FindRefToDistArrayFromList(), gen_free_list(), gen_nconc(), generate_read_of_ref_for_all(), host_module, instruction_call, instruction_to_statement(), is_instruction_call, lUpdateExpr(), make_call(), make_instruction(), MAP, NIL, node_module, pips_assert, pips_debug, reference_variable, STATEMENT, statement_call_p(), statement_instruction, SYNTAX, syntax_reference, and syntax_reference_p.

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_compute_local_indices()

void generate_compute_local_indices	(	reference	ref,
		list *	lsp,
		list *	lindsp
	)

generate_compute_local_indices

this function generate the list of statement necessary to compute the local indices of the given reference. It gives back the new list of indices for the reference.

Parameters

ref	ef
lsp	sp
lindsp	indsp

Definition at line 388 of file generate.c.

{
    int i;
    entity array = reference_variable(ref);
    list inds = reference_indices(ref);
 
    pips_assert("distributed array", array_distributed_p(array));
 
    (*lsp) = NIL, (*lindsp) = NIL;
 
    pips_debug(9, "number of dimensions of %s to compute: %d\n",
          entity_name(array), NumberOfDimension(array));
 
    for(i=1; i<=NumberOfDimension(array); i++, inds = CDR(inds))
    {
        if (local_index_is_different_p(array, i))
        {
            syntax s;
            statement stat = st_compute_ith_local_index(array, i,
                                              EXPRESSION(CAR(inds)), &s);
 
            DEBUG_STAT(9, entity_name(node_module), stat);
 
            (*lsp) = gen_nconc((*lsp), CONS(STATEMENT, stat, NIL));
            (*lindsp) =
                gen_nconc((*lindsp), CONS(EXPRESSION,
                           make_expression(s, normalized_undefined), NIL));
        }
        else
        {
            expression expr =
                UpdateExpressionForModule(node_module, EXPRESSION(CAR(inds)));
 
            (*lindsp) =
                gen_nconc((*lindsp),
                          CONS(EXPRESSION, expr, NIL));
        }
    }
 
    pips_debug(8, "result:\n");
    ifdebug(8)
        MAP(STATEMENT, s, DEBUG_STAT(8, entity_name(node_module), s), (*lsp));
}

References array, array_distributed_p(), CAR, CDR, CONS, DEBUG_STAT, entity_name, EXPRESSION, gen_nconc(), ifdebug, local_index_is_different_p, make_expression(), MAP, NIL, node_module, normalized_undefined, NumberOfDimension(), pips_assert, pips_debug, ref, reference_indices, reference_variable, st_compute_ith_local_index(), STATEMENT, and UpdateExpressionForModule().

Referenced by generate_c1_alpha(), generate_get_value_locally(), generate_parallel_body(), generate_receive_from_computer(), generate_send_to_computer(), generate_update_distributed_value_from_host(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), and st_send_to_computer_if_necessary().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_copy_loop_nest()

statement generate_copy_loop_nest	(	entity	src,
		entity	trg
	)

statement generate_copy_loop_nest(src, trg) entity src, trg;

what: generates a parallel loop nest that copies src in trg. how: by building the corresponding AST. input: the two entities, which should be arrays with the same shape. output: a statement containing the loop nest. side effects:

• adds a few new variables for the loop indexes. bugs or features:
• could be more general?

of entities

of expressions

of dimensions

???

builds the set of indexes needed to scan the dimensions.

builds the assign statement to put in the body. TRG(indexes) = SRC(indexes)

builds the copy loop nest

Parameters

src	rc
trg	rg

Definition at line 1568 of file dynamic.c.

{
    type t = entity_type(src);
    list /* of entities */    indexes = NIL,
         /* of expressions */ idx_expr,
         /* of dimensions */  dims;
    statement current;
    entity module;
    int ndims, i;
 
    if (src==trg) return make_empty_statement();
 
    pips_assert("valid arguments",
                array_distributed_p(src) && array_distributed_p(trg) &&
                type_variable_p(t) &&
                load_primary_entity(src)==load_primary_entity(trg)); /* ??? */
 
    dims = variable_dimensions(type_variable(t));
    ndims = gen_length(dims);
    
    /*  builds the set of indexes needed to scan the dimensions.
     */
    for(module=get_current_module_entity(), i=ndims; i>0; i--)
      indexes = CONS(ENTITY, 
                     hpfc_new_variable(module, MakeBasic(is_basic_int)),
                     indexes);
 
    idx_expr = entities_to_expressions(indexes);
 
    /*  builds the assign statement to put in the body.
     *  TRG(indexes) = SRC(indexes)
     */
    current = make_assign_statement
        (reference_to_expression(make_reference(trg, idx_expr)),
         reference_to_expression(make_reference(src, gen_copy_seq(idx_expr))));
 
    /*  builds the copy loop nest
     */
    for(; ndims>0; POP(dims), POP(indexes), ndims--)
    {
        dimension d = DIMENSION(CAR(dims));
        
        current = loop_to_statement
            (make_loop(ENTITY(CAR(indexes)),
                       make_range(copy_expression(dimension_lower(d)),
                                  copy_expression(dimension_upper(d)),
                                  int_to_expression(1)),
                       current,
                       entity_empty_label(),
                       make_execution(is_execution_parallel, UU),
                       NIL));
    }
 
    DEBUG_STAT(7, concatenate(entity_name(src), " -> ", entity_name(trg), NULL),
               current);
 
    return current;
}

References array_distributed_p(), CAR, concatenate(), CONS, copy_expression(), current, DEBUG_STAT, DIMENSION, dimension_lower, dimension_upper, entities_to_expressions(), ENTITY, entity_empty_label(), entity_name, entity_type, gen_copy_seq(), gen_length(), get_current_module_entity(), hpfc_new_variable(), int_to_expression(), is_basic_int, is_execution_parallel, load_primary_entity(), loop_to_statement, make_assign_statement(), make_empty_statement, make_execution(), make_loop(), make_range(), make_reference(), MakeBasic(), module, NIL, pips_assert, POP, reference_to_expression(), src, type_variable, type_variable_p, UU, and variable_dimensions.

Referenced by clean_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_deducables()

statement generate_deducables

(

list

le

)

statement generate_deducables(list le)

the le list of expression is used to generate the deducables. The fields of interest are the variable which is referenced and the normalized field which is the expression that is going to be used to define the variable.

Parameters

le	of expression

Definition at line 83 of file generate-util.c.

{
    list rev = gen_nreverse(gen_copy_seq(le)), ls = NIL;
 
    MAP(EXPRESSION, e,
    {
        entity var = reference_variable(expression_reference(e));
        Pvecteur v = normalized_linear(expression_normalized(e));
 
        ls = CONS(STATEMENT, Pvecteur_to_assign_statement(var, v), ls);
    },
        rev);
 
    gen_free_list(rev);
    return make_block_statement(ls);
}

References CONS, EXPRESSION, expression_normalized, expression_reference(), gen_copy_seq(), gen_free_list(), gen_nreverse(), make_block_statement(), MAP, NIL, normalized_linear, Pvecteur_to_assign_statement(), reference_variable, and STATEMENT.

Referenced by elements_loop(), generate_io_statements_for_shared_arrays(), and GENERATION().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_full_copy()

statement generate_full_copy	(	reference	left,
		reference	right
	)

statement generate_full_copy(reference left, reference right)

what: copies directly right into left, that must conform... how: direct loop nest on local data input: both entities output: the returned statement side effects: bugs or features:

• assumes that the references are ok, that is they come from a full_copy_p execution.
• code generated based on the original entities. thus the code cleaning pass is trusted.

of entity

of dimension

indexes are reused. bounds are taken from the node entity declaration.

Parameters

left	eft
right	ight

Definition at line 964 of file special_cases.c.

{
    statement body;
    int ndim, i;
    list /* of entity */ lindexes, l,
         /* of dimension */ ld;
    entity array = reference_variable(left), 
           new_array = load_new_node(array);
 
    ndim = gen_length(variable_dimensions(type_variable(entity_type(array))));
 
    body = make_assign_statement(reference_to_expression(copy_reference(left)),
                              reference_to_expression(copy_reference(right)));
    
    /* indexes are reused. bounds are taken from the node entity declaration.
     */
    lindexes = expressions_to_entities(reference_indices(left));
    ld = variable_dimensions(type_variable(entity_type(new_array)));
 
    for(i=1, l=lindexes; i<=ndim; i++, POP(lindexes), POP(ld))
    {
        dimension d = DIMENSION(CAR(ld));
 
        body = loop_to_statement(make_loop
           (ENTITY(CAR(lindexes)),
            make_range(copy_expression(dimension_lower(d)),
                       copy_expression(dimension_upper(d)),
                       int_to_expression(1)),
            body,
            entity_empty_label(),
            make_execution(is_execution_sequential, UU),
            NIL));
    }
 
    gen_free_list(l);
    return body;    
}

References array, CAR, copy_expression(), copy_reference(), DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_empty_label(), entity_type, expressions_to_entities(), gen_free_list(), gen_length(), int_to_expression(), is_execution_sequential, load_new_node(), loop_to_statement, make_assign_statement(), make_execution(), make_loop(), make_range(), NIL, POP, reference_indices, reference_to_expression(), reference_variable, type_variable, UU, and variable_dimensions.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_get_value_locally()

void generate_get_value_locally	(	reference	ref,
		reference	goal,
		list *	lstatp
	)

generate_get_value_locally

put the local value of ref in the variable local.

for every indexes, if necessary, compute the local value of the indices, by calling RTR support function LOCAL_INDEX(array_number, dimension) then the assignment is performed.

tempi = LOCAL_INDEX(array_number, dimension, indexi) ... goal = ref_local(tempi...)

Parameters

ref	ef
goal	oal
lstatp	statp

Definition at line 446 of file generate.c.

{
    statement stat;
    expression expr;
    entity array = reference_variable(ref),
           newarray = load_new_node(array);
    list ls = NIL, newinds = NIL;
 
    pips_assert("distributed array", array_distributed_p(array));
 
    generate_compute_local_indices(ref, &ls, &newinds);
    expr = reference_to_expression(make_reference(newarray, newinds));
    stat = make_assign_statement(reference_to_expression(goal), expr);
 
    DEBUG_STAT(9, entity_name(node_module), stat);
 
    (*lstatp) = gen_nconc(ls, CONS(STATEMENT, stat, NIL));
}

References array, array_distributed_p(), CONS, DEBUG_STAT, entity_name, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_assign_statement(), make_reference(), NIL, node_module, pips_assert, ref, reference_to_expression(), reference_variable, and STATEMENT.

Referenced by st_get_value_for_computer(), and st_get_value_locally_and_send().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_guarded_statement()

statement generate_guarded_statement	(	statement	stat,
		entity	proc,
		list	lr
	)

Parameters

stat	tat
proc	roc
lr	r

Definition at line 680 of file message-utils.c.

{
    expression guard;
 
    return((make_guard_expression(proc, lr, &guard))?
           (instruction_to_statement
            (make_instruction(is_instruction_test,
                              make_test(guard,
                                        stat,
                                        make_continue_statement
                                        (entity_empty_label()))))):
           stat);
}

References entity_empty_label(), instruction_to_statement(), is_instruction_test, make_continue_statement(), make_guard_expression(), make_instruction(), and make_test().

Referenced by loop_nest_guard(), and st_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_io_statements_for_distributed_arrays()

void generate_io_statements_for_distributed_arrays	(	entity	,
		tag	,
		Psysteme	,
		Psysteme	,
		Psysteme	,
		list	,
		list	,
		list	,
		list	,
		statement *	,
		statement *
	)

Referenced by generate_io_collect_or_update().

Here is the caller graph for this function:

generate_io_statements_for_shared_arrays()

void generate_io_statements_for_shared_arrays	(	entity	,
		tag	,
		Psysteme	,
		Psysteme	,
		list	,
		list	,
		list	,
		statement *	,
		statement *
	)

Referenced by generate_io_collect_or_update().

Here is the caller graph for this function:

generate_message_from_3_lists()

list generate_message_from_3_lists	(	entity	array,
		list	lcontent,
		list	lneighbour,
		list	ldomain
	)

list generate_message_from_3_lists(array, lcontent, lneighbour, ldomain)

Parameters

array	rray
lcontent	content
lneighbour	neighbour
ldomain	domain

Definition at line 173 of file message-utils.c.

{
    list lc = lcontent, ln = lneighbour, ld = ldomain, lm = NIL;
    int len = gen_length(lcontent);
 
    assert(len==(int)gen_length(lneighbour) && len==(int)gen_length(ldomain));
 
    for ( ; lc!=NIL ; lc=CDR(lc), ln=CDR(ln), ld=CDR(ld))
    {
        lm = CONS(MESSAGE,
                  make_message(array,
                               CONSP(CAR(lc)),
                               (Pvecteur)PVECTOR(CAR(ln)),
                               CONSP(CAR(ld))),
                  lm);                         
    }
 
    return(lm);
}

References array, assert, CAR, CDR, CONS, CONSP, gen_length(), make_message(), MESSAGE, NIL, and PVECTOR.

Referenced by atomize_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_parallel_body()

void generate_parallel_body	(	statement	body,
		list *	lstatp,
		list	lw,
		list	lr
	)

the first written or read distributed ref is chosen as the computer

we are sure that computer is one of the owners

Parameters

body	ody
lstatp	statp
lw	w
lr	r

Definition at line 511 of file generate.c.

{
    statement statcc, statbody;
    list lcomp = NIL, lcompr = NIL, lcompw = NIL,
        lnotcomp = NIL, lnotcompr = NIL, lnotcompw = NIL;
    syntax comp;
 
    pips_assert("at leat one written or read",
                (gen_length(lw)+gen_length(lr))>0);
 
    /* the first written or read distributed ref is chosen as the computer
     */
    comp = lw? SYNTAX(CAR(lw)): SYNTAX(CAR(lr));
    statcc = st_compute_current_computer(syntax_reference(comp));
 
    MAP(SYNTAX, s,
     {
         list lco = NIL;
         list lnotco = NIL;
 
         generate_read_of_ref_for_computer(s, &lco, &lnotco);
 
         lcompr = gen_nconc(lcompr, lco);
         lnotcompr = gen_nconc(lnotcompr, lnotco);
     },
         lr);
 
    MAP(SYNTAX, s,
     {
         list lco = NIL;
         list lnotco = NIL;
         reference r = syntax_reference(s);
         entity var = reference_variable(r);
         entity temp = make_new_scalar_variable(get_current_module_entity(),
                                         entity_basic(var));
         entity tempn ;
 
         AddEntityToHostAndNodeModules(temp);
         tempn = load_new_node( temp);
 
         if (comp == s)
         {
             /* we are sure that computer is one of the owners
              */
             list lstat = NIL;
             list linds = NIL;
             entity newarray = load_new_node(var);
 
             generate_compute_local_indices(r, &lstat, &linds);
             lstat =
                 gen_nconc
                     (lstat,
                      CONS(STATEMENT,
                           make_assign_statement
                             (reference_to_expression(make_reference(newarray,
                                                                     linds)),
                              entity_to_expression(tempn)),
                           NIL));
 
             generate_update_values_on_nodes
                 (r, make_reference(tempn, NIL), &lco, &lnotco);
 
             lco = gen_nconc(lstat, lco);
         }
         else
         {
             generate_update_values_on_computer_and_nodes
                 (r, make_reference(tempn, NIL), &lco, &lnotco);
         }
 
         lcompw = gen_nconc(lcompw, lco);
         lnotcompw = gen_nconc(lnotcompw, lnotco);
 
         syntax_reference(s) = make_reference(temp, NIL);
     },
         lw);
 
 
    pips_debug(6, "%zd statements for computer write:\n", gen_length(lcompw));
 
    ifdebug(8)
    {
        MAP(STATEMENT, s, DEBUG_STAT(8, entity_name(node_module), s), lcompw);
    }
 
    pips_debug(6, "%zd statements for not computer write:\n",
               gen_length(lnotcompw));
 
    ifdebug(8)
    {
        MAP(STATEMENT, s, DEBUG_STAT(8, entity_name(node_module), s),
            lnotcompw);
    }
 
    statbody = UpdateStatementForModule(node_module, body);
    DEBUG_STAT(7, entity_name(node_module), statbody);
 
    lcomp = gen_nconc(lcompr, CONS(STATEMENT, statbody, lcompw));
    lnotcomp = gen_nconc(lnotcompr, lnotcompw);
 
    (*lstatp) = CONS(STATEMENT, statcc,
                CONS(STATEMENT, st_make_nice_test(condition_computerp(),
                                                  lcomp,
                                                  lnotcomp),
                     NIL));
 
    ifdebug(6)
    {
        pips_debug(6, "final statement:\n");
        MAP(STATEMENT, s, DEBUG_STAT(6, entity_name(node_module),s), (*lstatp));
    }
}

References AddEntityToHostAndNodeModules(), CAR, condition_computerp, CONS, DEBUG_STAT, entity_basic(), entity_name, entity_to_expression(), gen_length(), gen_nconc(), generate_compute_local_indices(), generate_read_of_ref_for_computer(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), get_current_module_entity(), ifdebug, load_new_node(), make_assign_statement(), make_new_scalar_variable(), make_reference(), MAP, NIL, node_module, pips_assert, pips_debug, reference_to_expression(), reference_variable, st_compute_current_computer(), st_make_nice_test(), STATEMENT, SYNTAX, syntax_reference, and UpdateStatementForModule().

Referenced by hpf_compile_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_read_of_ref_for_all()

void generate_read_of_ref_for_all	(	syntax	s,
		list *	lhp,
		list *	lnp
	)

generate_read_of_ref_for_all

this function organise the read of the given reference for all the nodes, and for host.

the receive statement is built for host:

COMPUTE_CURRENT_OWNERS(ref) temp = RECEIVEFROMSENDER(...)

a receive from sender is generated, however replicated the variable is FC 930623 (before was a call to st_receive_from(ref, ...))

the code for node is built, in order that temp has the wanted value.

COMPUTE_CURRENT_OWNERS(ref) IF OWNERP(ME) THEN local_ref = COMPUTE_LOCAL(ref) temp = (local_ref) IF SENDERP(ME) // this protection in case of replicated arrays. THEN SENDTOHOST(temp) SENDTONODE(ALL-OWNERS,temp) ENDIF ELSE temp = RECEIVEFROM(SENDER(...)) ENDIF

the new variable is inserted in the expression...

Parameters

lhp	hp
lnp	np

Definition at line 316 of file generate.c.

{
    statement stathco, stathrcv, statnco, statngv;
    reference ref = syntax_reference(s);
    entity temph, tempn,
        var = reference_variable(ref),
        temp = make_new_scalar_variable(get_current_module_entity(),
                                    entity_basic(var));
 
    pips_assert("distributed array", array_distributed_p(var));
 
    AddEntityToHostAndNodeModules(temp);
    temph = load_new_host(temp);
    tempn = load_new_node(temp);
 
    /* the receive statement is built for host:
     *
     * COMPUTE_CURRENT_OWNERS(ref)
     * temp = RECEIVEFROMSENDER(...)
     */
    stathco = st_compute_current_owners(ref);
 
    /* a receive from sender is generated, however replicated the variable is
     * FC 930623 (before was a call to st_receive_from(ref, ...))
     */
    stathrcv = st_receive_from(ref, make_reference(temph, NIL));
 
    (*lhp) = CONS(STATEMENT, stathco,
             CONS(STATEMENT, stathrcv,
                  NIL));
 
    DEBUG_STAT(9, entity_name(host_module), stathco);
    DEBUG_STAT(9, entity_name(host_module), stathrcv);
 
    /* the code for node is built, in order that temp has the
     * wanted value.
     *
     * COMPUTE_CURRENT_OWNERS(ref)
     * IF OWNERP(ME)
     * THEN
     *   local_ref = COMPUTE_LOCAL(ref)
     *   temp = (local_ref)
     *   IF SENDERP(ME) // this protection in case of replicated arrays.
     *   THEN
     *       SENDTOHOST(temp)
     *   SENDTONODE(ALL-OWNERS,temp)
     *   ENDIF
     * ELSE
     *   temp = RECEIVEFROM(SENDER(...))
     * ENDIF
     */
    statnco = st_compute_current_owners(ref);
    statngv = st_get_value_for_all(ref, make_reference(tempn, NIL));
 
    (*lnp) = CONS(STATEMENT, statnco, CONS(STATEMENT, statngv, NIL));
 
    DEBUG_STAT(9, entity_name(node_module), statnco);
    DEBUG_STAT(9, entity_name(node_module), statngv);
 
    /* the new variable is inserted in the expression...
     */
    syntax_reference(s) = make_reference(temp, NIL);
}

References AddEntityToHostAndNodeModules(), array_distributed_p(), CONS, DEBUG_STAT, entity_basic(), entity_name, get_current_module_entity(), host_module, load_new_host(), load_new_node(), make_new_scalar_variable(), make_reference(), NIL, node_module, pips_assert, ref, reference_variable, st_compute_current_owners(), st_get_value_for_all(), st_receive_from(), STATEMENT, and syntax_reference.

Referenced by generate_c1_beta().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_read_of_ref_for_computer()

void generate_read_of_ref_for_computer	(	syntax	s,
		list *	lcompp,
		list *	lnotcompp
	)

generate_read_of_ref_for_computer

en cours d'adaptation...

the new variable is inserted in the expression...

Parameters

lcompp	compp
lnotcompp	notcompp

Definition at line 275 of file generate.c.

{
    statement statcompco, statcompgv, statnotcompco, statnotcompmaysend;
    reference ref = syntax_reference(s);
    entity tempn,
        var = reference_variable(ref),
        temp = make_new_scalar_variable(get_current_module_entity(),
                                    entity_basic(var));
 
    pips_assert("distributed array", array_distributed_p(var));
 
    AddEntityToHostAndNodeModules(temp);
    tempn = load_new_node(temp);
 
    statcompco = st_compute_current_owners(ref);
    statcompgv = st_get_value_for_computer(ref, make_reference(tempn, NIL));
 
    (*lcompp) = CONS(STATEMENT, statcompco,
                CONS(STATEMENT, statcompgv, NIL));
 
    statnotcompco = st_compute_current_owners(ref);
    statnotcompmaysend = st_send_to_computer_if_necessary(ref);
 
 
    (*lnotcompp) =
        CONS(STATEMENT, statnotcompco,
        CONS(STATEMENT, statnotcompmaysend,
             NIL));
 
    /* the new variable is inserted in the expression...
     */
    syntax_reference(s) = make_reference(temp, NIL);
}

References AddEntityToHostAndNodeModules(), array_distributed_p(), CONS, entity_basic(), get_current_module_entity(), load_new_node(), make_new_scalar_variable(), make_reference(), NIL, pips_assert, ref, reference_variable, st_compute_current_owners(), st_get_value_for_computer(), st_send_to_computer_if_necessary(), STATEMENT, and syntax_reference.

Referenced by generate_c1_alpha(), and generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_receive_from_computer()

void generate_receive_from_computer	(	reference	ref,
		list *	lstatp
	)

Parameters

ref	ef
lstatp	statp

Definition at line 491 of file generate.c.

{
    statement statrcv;
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    list ls = NIL, newinds = NIL;
 
    pips_assert("distributed array", array_distributed_p(array));
 
    generate_compute_local_indices(ref, &ls, &newinds);
    statrcv = st_receive_from_computer(make_reference(newarray, newinds));
 
    DEBUG_STAT(9, entity_name(node_module), statrcv);
 
    (*lstatp) = gen_nconc(ls, CONS(STATEMENT, statrcv, NIL));
}

References array, array_distributed_p(), CONS, DEBUG_STAT, entity_name, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_reference(), NIL, node_module, pips_assert, ref, reference_variable, st_receive_from_computer, and STATEMENT.

Here is the call graph for this function:

generate_send_to_computer()

void generate_send_to_computer	(	reference	ref,
		list *	lstatp
	)

generate_send_to_computer

sends the local value of ref to the current computer

Parameters

ref	ef
lstatp	statp

Definition at line 471 of file generate.c.

{
    statement statsnd;
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    list ls = NIL, newinds = NIL;
 
    pips_assert("distributed array", array_distributed_p(array));
 
    generate_compute_local_indices(ref, &ls, &newinds);
    statsnd = st_send_to_computer(make_reference(newarray, newinds));
 
    DEBUG_STAT(9, entity_name(node_module), statsnd);
 
    (*lstatp) = gen_nconc(ls, CONS(STATEMENT, statsnd, NIL));
}

References array, array_distributed_p(), CONS, DEBUG_STAT, entity_name, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_reference(), NIL, node_module, pips_assert, ref, reference_variable, st_send_to_computer, and STATEMENT.

Here is the call graph for this function:

generate_subarray_shift()

statement generate_subarray_shift	(	statement	s,
		entity	var,
		list	lshift
	)

statement generate_subarray_shift(s, var, lshift) statement s; entity var; list lshift;

generates a call to the runtime library shift subroutine for the given array, the given shift and the corresponding region in statement s. this function assumes that subarray_shift_p was true on s, and does not checks the conditions again.

gets the shifted dimension and the shift

all the arguments

Parameters

var	ar
lshift	shift

Definition at line 643 of file special_cases.c.

{
    entity subroutine = make_shift_subroutine(var);
    int array_number = load_hpf_number(array), shifted_dim = 0;
    expression shift = expression_undefined;
    list ldecl = array_lower_upper_bounds_list(array), largs;
    Pvecteur v;
 
    /*  gets the shifted dimension and the shift
     */
    MAPL(cv,
     {
         v = (Pvecteur) PVECTOR(CAR(cv));
         shifted_dim++;
 
         if (!vecteur_nul_p(v)) 
         {
             shift = make_vecteur_expression(v);
             break;
         }
     },
         lshift);
 
    pips_assert("shift defined", shift!=expression_undefined);
    free_vector_list(lshift);
    
    /*  all the arguments
     */
    largs = 
        CONS(EXPRESSION, entity_to_expression(array),
        CONS(EXPRESSION, int_to_expression(array_number),
        CONS(EXPRESSION, int_to_expression(shifted_dim),
        CONS(EXPRESSION, shift,
             gen_nconc(ldecl, make_rectangular_area(s, var))))));
 
    return hpfc_make_call_statement(subroutine, largs);
}

References array, array_lower_upper_bounds_list(), CAR, CONS, entity_to_expression(), EXPRESSION, expression_undefined, free_vector_list(), gen_nconc(), hpfc_make_call_statement(), int_to_expression(), load_hpf_number(), make_rectangular_area(), make_shift_subroutine(), make_vecteur_expression(), MAPL, pips_assert, PVECTOR, and vecteur_nul_p().

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_system_for_distributed_variable()

Psysteme generate_system_for_distributed_variable

(

entity

v

)

Psysteme generate_system_for_variable(v) entity v;.

what: generates a system for DISTRIBUTED variable v. how: uses the declarations of v, t, p and align and distribute, and new declarations. input: entity (variable) v output: the built system, which is a new allocated system. side effects:

• uses many functions that build and store systems... bugs or features:

Definition at line 789 of file build-system.c.

{
    Psysteme result = sc_rn(NULL);
    entity t, p;
 
    pips_assert("distributed array", array_distributed_p(v));
 
    t = align_template(load_hpf_alignment(v)),
    p = distribute_processors(load_hpf_distribution(t));    
 
    result = sc_append(result, entity_to_declaration_constraints(v, 0));
    result = sc_append(result, entity_to_declaration_constraints(t, 1));
    result = sc_append(result, entity_to_declaration_constraints(p, 2));
    result = sc_append(result, entity_to_hpf_align_constraints(v));
    result = sc_append(result, entity_to_hpf_distribute_constraints(t));
    result = sc_append(result, entity_to_new_declaration(v));
 
    base_rm(sc_base(result)), sc_base(result) = NULL, sc_creer_base(result);
 
    return(result);
}

References align_template, array_distributed_p(), base_rm, distribute_processors, entity_to_declaration_constraints(), entity_to_hpf_align_constraints(), entity_to_hpf_distribute_constraints(), entity_to_new_declaration(), load_hpf_alignment(), load_hpf_distribution(), pips_assert, sc_append(), sc_creer_base(), and sc_rn().

Referenced by generate_distributed_io_system(), and generate_remapping_system().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_system_for_equal_variables()

Psysteme generate_system_for_equal_variables	(	int	n,
		entity(*)(int)	gen1,
		entity(*)(int)	gen2
	)

Definition at line 751 of file build-system.c.

{
    Psysteme s = sc_rn(NULL);
 
    for(; n>0; n--)
        sc_add_egalite(s, contrainte_make
             (vect_make(VECTEUR_NUL, gen1(n), VALUE_ONE, 
                        gen2(n), VALUE_MONE, TCST, VALUE_ZERO)));
 
    sc_creer_base(s); return s;
}

References contrainte_make(), sc_add_egalite(), sc_creer_base(), sc_rn(), TCST, VALUE_MONE, VALUE_ONE, VALUE_ZERO, vect_make(), and VECTEUR_NUL.

Referenced by generate_remapping_system(), and hpfc_unstutter_dummies().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_update_distributed_value_from_host()

void generate_update_distributed_value_from_host	(	syntax	s,
		list *	lhstatp,
		list *	lnstatp
	)

generate_update_distributed_value_from_host

call the necessary communication function

Parameters

lhstatp	hstatp
lnstatp	nstatp

Definition at line 691 of file generate.c.

{
    reference r = syntax_reference(s);
    entity array, newarray, temp, temph;
    statement statnco, stathco, stnrcv, stnif, sthsnd;
    list linds = NIL, lnstat = NIL;
 
    pips_assert("distrivuted reference",
                array_distributed_p(reference_variable(syntax_reference(s))));
 
    array    = reference_variable(r);
    newarray = load_new_node(array);
 
    temp     = make_new_scalar_variable(get_current_module_entity(),
                                    entity_basic(array));
 
    AddEntityToHostAndNodeModules(temp);
    temph = load_new_host(temp);
 
    generate_compute_local_indices(r, &lnstat, &linds);
    stnrcv = st_receive_from_host(make_reference(newarray, linds));
    stnif = st_make_nice_test(condition_ownerp(),
                              gen_nconc(lnstat,
                                        CONS(STATEMENT, stnrcv, NIL)),
                              NIL);
 
    /* call the necessary communication function
     */
 
    sthsnd = (replicated_p(array) ?
              st_send_to_owners(make_reference(temph, NIL)) :
              st_send_to_owner(make_reference(temph, NIL))) ;
 
    syntax_reference(s) = make_reference(temp, NIL);
 
    statnco = st_compute_current_owners(r);
    stathco = st_compute_current_owners(r);
 
    (*lhstatp) = CONS(STATEMENT, stathco, CONS(STATEMENT, sthsnd, NIL));
    (*lnstatp) = CONS(STATEMENT, statnco, CONS(STATEMENT, stnif, NIL));
 
}

References AddEntityToHostAndNodeModules(), array, array_distributed_p(), condition_ownerp, CONS, entity_basic(), gen_nconc(), generate_compute_local_indices(), get_current_module_entity(), load_new_host(), load_new_node(), make_new_scalar_variable(), make_reference(), NIL, pips_assert, reference_variable, replicated_p(), st_compute_current_owners(), st_make_nice_test(), st_receive_from_host, st_send_to_owner, st_send_to_owners, STATEMENT, and syntax_reference.

Here is the call graph for this function:

generate_update_private_value_from_host()

void generate_update_private_value_from_host	(	syntax	s,
		list *	lhstatp,
		list *	lnstatp
	)

generate_update_private_value_from_host

Parameters

lhstatp	hstatp
lnstatp	nstatp

Definition at line 738 of file generate.c.

{
  entity
    var  = reference_variable(syntax_reference(s)),
    varn = load_new_node(var),
    varh = load_new_host(var);
 
  pips_assert("not distributed reference",
              !array_distributed_p(reference_variable(syntax_reference(s))));
 
  (*lhstatp) = CONS(STATEMENT,
                    st_host_send_to_all_nodes(make_reference(varh, NIL)),
                    NIL);
 
  (*lnstatp) = CONS(STATEMENT,
                    st_receive_mcast_from_host(make_reference(varn, NIL)),
                    NIL);
}

References array_distributed_p(), CONS, load_new_host(), load_new_node(), make_reference(), NIL, pips_assert, reference_variable, st_host_send_to_all_nodes, st_receive_mcast_from_host, STATEMENT, and syntax_reference.

Here is the call graph for this function:

generate_update_values_on_computer_and_nodes()

void generate_update_values_on_computer_and_nodes	(	reference	ref,
		reference	val,
		list *	lscompp,
		list *	lsnotcompp
	)

generate_update_values_on_computer_and_nodes

inside a loop, a variable is defined, and the values have to be updated on the computer node itself, and on the other owners of the given variable.

computer is doing the job

all values have to be updated...

Parameters

ref	ef
val	al
lscompp	scompp
lsnotcompp	snotcompp

Definition at line 634 of file generate.c.

{
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    statement
        statif, statcompif, statco, statcompco, statcompassign,
        statsndtoO, statsndtoOO, statrcvfromcomp;
    list lstat, lstatcomp, linds, lindscomp;
 
    /* all values have to be updated...
     */
    statcompco = st_compute_current_owners(ref);
    generate_compute_local_indices(ref, &lstatcomp, &lindscomp);
 
    statcompassign =
        make_assign_statement
            (reference_to_expression(make_reference(newarray, lindscomp)),
             reference_to_expression(val));
 
    if (replicated_p(array))
    {
        statsndtoOO = st_send_to_other_owners(val);
        statsndtoO  = st_send_to_owners(val);
    }
    else
    {
        statsndtoOO = make_continue_statement(entity_undefined);
        statsndtoO  = st_send_to_owner(val);
    }
    statcompif = st_make_nice_test
        (condition_ownerp(),
         gen_nconc(lstatcomp, CONS(STATEMENT, statcompassign,
                              CONS(STATEMENT, statsndtoOO,
                                   NIL))),
         CONS(STATEMENT, statsndtoO,
              NIL));
 
    statco = st_compute_current_owners(ref);
    generate_compute_local_indices(ref, &lstat, &linds);
    statrcvfromcomp =
        st_receive_from_computer(make_reference(newarray,linds));
    statif = st_make_nice_test(condition_ownerp(),
                               gen_nconc(lstat, CONS(STATEMENT, statrcvfromcomp,
                                                     NIL)),
                               NIL);
 
    (*lscompp) = CONS(STATEMENT, statcompco,
                 CONS(STATEMENT, statcompif, NIL));
    (*lsnotcompp) = CONS(STATEMENT, statco,
                    CONS(STATEMENT, statif, NIL));
}

References array, condition_ownerp, CONS, entity_undefined, gen_nconc(), generate_compute_local_indices(), load_new_node(), make_assign_statement(), make_continue_statement(), make_reference(), NIL, ref, reference_to_expression(), reference_variable, replicated_p(), st_compute_current_owners(), st_make_nice_test(), st_receive_from_computer, st_send_to_other_owners, st_send_to_owner, st_send_to_owners, and STATEMENT.

Referenced by generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_update_values_on_nodes()

void generate_update_values_on_nodes	(	reference	ref,
		reference	newref,
		list *	lscompp,
		list *	lsnotcompp
	)

generate_update_values_on_nodes

computer is doing the job

remote values have to be updated

the computer has to compute the owners in order to call the send to other owners function, because the owners are used to define the owners set, which was quite obvious:-)

bug fixed by FC, 930629

Parameters

ref	ef
newref	ewref
lscompp	scompp
lsnotcompp	snotcompp

Definition at line 223 of file generate.c.

{
    entity array = reference_variable(ref);
 
    if (replicated_p(array))
    {
        statement statif, statco, statco2, statsndtoon, statrcvfromcomp;
        list lstat, linds;
 
        /* remote values have to be updated
         */
        statco = st_compute_current_owners(ref);
 
        /* the computer has to compute the owners in order to call
         * the send to other owners function, because the owners
         * are used to define the owners set, which was quite obvious:-)
         *
         * bug fixed by FC, 930629
         */
        statco2 = st_compute_current_owners(ref);
        statsndtoon = st_send_to_other_owners(newref);
        generate_compute_local_indices(ref, &lstat, &linds);
        statrcvfromcomp =
            st_receive_from_computer(make_reference(reference_variable(newref),
                                                    linds));
        statif = st_make_nice_test(condition_ownerp(),
                                   gen_nconc(lstat,
                                             CONS(STATEMENT,
                                                  statrcvfromcomp,
                                                  NIL)),
                                   NIL);
 
        (*lscompp) = CONS(STATEMENT, statco2,
                     CONS(STATEMENT, statsndtoon,
                          NIL));
        (*lsnotcompp) = CONS(STATEMENT, statco,
                        CONS(STATEMENT, statif,
                             NIL));
    }
    else
    {
        (*lscompp) = NIL;
        (*lsnotcompp) = NIL;
    }
}

References array, condition_ownerp, CONS, gen_nconc(), generate_compute_local_indices(), make_reference(), NIL, ref, reference_variable, replicated_p(), st_compute_current_owners(), st_make_nice_test(), st_receive_from_computer, st_send_to_other_owners, and STATEMENT.

Referenced by generate_c1_alpha(), and generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

get_alignment()

void get_alignment	(	entity	array,
		int	dim,
		int *	ptdim,
		int *	pa,
		int *	pb
	)

---

a nicer interface to extract the needed information. FC 29/03/94

replication

Parameters

array	rray
dim	im
ptdim	tdim
pa	a
pb	b

Definition at line 606 of file hpfc-util.c.

{ 
    align al = load_hpf_alignment(array);
    alignment a;
    
    pips_assert("distributed array", array_distributed_p(array));
    
    *ptdim = template_dimension_of_array_dimension(array, dim);
 
    if (*ptdim==-1) /* replication */
    {
        *pa=0, *pb=0;
        return;
    }
 
    a = FindAlignmentOfTemplateDim(align_alignment(al), *ptdim);
 
    if (a==alignment_undefined)
    {
        pips_assert("not aligned", *ptdim==0);
        *pa = 0; *pb = 0;
    }
    else
    {
        pips_assert("aligned", *ptdim>=1);
        *pa = HpfcExpressionToInt(alignment_rate(a));
        *pb = HpfcExpressionToInt(alignment_constant(a));
    }
}

References align_alignment, alignment_constant, alignment_rate, alignment_undefined, array, array_distributed_p(), FindAlignmentOfTemplateDim(), HpfcExpressionToInt(), load_hpf_alignment(), pips_assert, and template_dimension_of_array_dimension().

Referenced by alignments_compatible_p(), and hpfc_compute_entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

get_data_status()

data_status get_data_status

(

void

)

??? previsous data_status lost: memory leak

Definition at line 308 of file declarations.c.

{
    /* ??? previsous data_status lost: memory leak
     */
    return(make_data_status(get_new_declaration(),
                            get_hpf_alignment(), 
                            get_hpf_distribution(),                         
                            list_of_distributed_arrays(),
                            list_of_templates(),
                            list_of_processors()));
}

References get_hpf_alignment(), get_hpf_distribution(), list_of_distributed_arrays(), list_of_processors(), list_of_templates(), and make_data_status().

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_distribution()

void get_distribution	(	entity	template,
		int	dim,
		int *	ppdim,
		int *	pn
	)

Parameters

template	emplate
dim	im
ppdim	pdim
pn	n

Definition at line 638 of file hpfc-util.c.

{
    distribution
        d = FindDistributionOfDim
            (distribute_distribution(load_hpf_distribution(template)), 
                                     dim, ppdim);
 
    *pn = (distribution_undefined_p(d) ?
           -1: HpfcExpressionToInt(distribution_parameter(d)));
}

References distribute_distribution, distribution_parameter, distribution_undefined_p, FindDistributionOfDim(), HpfcExpressionToInt(), and load_hpf_distribution().

Referenced by hpfc_compute_entity_to_new_declaration(), and processor_dimension_of_template_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

get_dynamic_hpf()

entity_entities get_dynamic_hpf

(

void

)

Referenced by get_dynamic_status().

Here is the caller graph for this function:

get_dynamic_status()

dynamic_status get_dynamic_status

(

void

)

get_similar_mapping()

Definition at line 99 of file dynamic.c.

{
    return make_dynamic_status(get_dynamic_hpf(), 
                               get_primary_entity(), 
                               get_renamings(),
                               get_maybeuseful_mappings());
    /* get_similar_mapping() */
}

References get_dynamic_hpf(), get_maybeuseful_mappings(), get_primary_entity(), get_renamings(), and make_dynamic_status().

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_entity_dimensions()

void get_entity_dimensions	(	entity	e,
		int	dim,
		int *	plow,
		int *	pup
	)

Parameters

dim	im
plow	low
pup	up

Definition at line 651 of file hpfc-util.c.

{
    dimension d = dimension_undefined;
 
    pips_assert("valid variable and dimension",
                entity_variable_p(e) && dim>0 && dim<=7);
 
    d = entity_ith_dimension(e, dim),
    *plow = ExpressionToInt(dimension_lower(d)),
    *pup = ExpressionToInt(dimension_upper(d));
}

References dimension_lower, dimension_undefined, dimension_upper, entity_ith_dimension(), entity_variable_p, ExpressionToInt(), and pips_assert.

Referenced by conformant_entities_p(), extract_the_align(), full_linearization(), hpfc_compute_entity_to_new_declaration(), hpfc_compute_lid(), partial_linearization(), and safe_static_domain_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

get_entity_status()

entity_status get_entity_status

(

void

)

Definition at line 93 of file host_node_entities.c.

{
    return make_entity_status(get_new_host(),
                              get_new_node(),
                              get_old_host(),
                              get_old_node(),
                              entity_int_undefined);
}

References entity_int_undefined, get_new_host(), get_new_node(), get_old_host(), get_old_node(), and make_entity_status().

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_hpf_alignment()

alignmap get_hpf_alignment

(

void

)

Referenced by get_data_status().

Here is the caller graph for this function:

get_hpf_distribution()

distributemap get_hpf_distribution

(

void

)

Referenced by get_data_status().

Here is the caller graph for this function:

get_hpf_number()

entity_int get_hpf_number

(

void

)

Referenced by get_hpf_number_status().

Here is the caller graph for this function:

get_hpf_number_status()

numbers_status get_hpf_number_status

(

void

)

Definition at line 134 of file declarations.c.

{
    return(make_numbers_status(get_hpf_number(),
                               current_array_index,
                               current_template_index,
                               current_processors_index));
}

References current_array_index, current_processors_index, current_template_index, get_hpf_number(), and make_numbers_status().

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_hpf_reductions()

statement_entities get_hpf_reductions

(

void

)

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the caller graph for this function:

get_hpfc_current_statement()

statement get_hpfc_current_statement

(

void

)

Referenced by write_on_entity_p().

Here is the caller graph for this function:

get_ith_array_dummy()

entity get_ith_array_dummy

(

int

)

Referenced by clean_distributed_io_system(), clean_shared_io_system(), generate_io_statements_for_shared_arrays(), generate_remapping_system(), hpfc_compute_align_constraints(), hpfc_compute_entity_to_new_declaration(), hpfc_order_variables(), hpfc_unstutter_dummies(), and remapping_variables().

Here is the caller graph for this function:

get_ith_array_prime()

entity get_ith_array_prime

(

int

)

Referenced by generate_remapping_system(), and remapping_variables().

Here is the caller graph for this function:

get_ith_auxiliary_dummy()

entity get_ith_auxiliary_dummy

(

int

)

Referenced by hpfc_compute_entity_to_new_declaration().

Here is the caller graph for this function:

get_ith_auxiliary_prime()

entity get_ith_auxiliary_prime

(

int

)

get_ith_block_dummy()

entity get_ith_block_dummy

(

int

)

Referenced by hpfc_compute_distribute_constraints(), hpfc_compute_entity_to_new_declaration(), hpfc_order_variables(), and remapping_variables().

Here is the caller graph for this function:

get_ith_block_prime()

entity get_ith_block_prime

(

int

)

Referenced by remapping_variables().

Here is the caller graph for this function:

get_ith_cycle_dummy()

entity get_ith_cycle_dummy

(

int

)

Referenced by hpfc_compute_distribute_constraints(), hpfc_compute_entity_to_new_declaration(), hpfc_order_variables(), and remapping_variables().

Here is the caller graph for this function:

get_ith_cycle_prime()

entity get_ith_cycle_prime

(

int

)

Referenced by remapping_variables().

Here is the caller graph for this function:

get_ith_dim_new_declaration()

void get_ith_dim_new_declaration	(	entity	array,
		int	i,
		int *	pmin,
		int *	pmax
	)

Parameters

array	rray
pmin	min
pmax	max

Definition at line 285 of file declarations.c.

{
    dimension d = entity_ith_dimension(load_new_node(array), i);
 
    pips_assert("distributed array",
                array_distributed_p(array) && entity_variable_p(array));
 
    *pmin = HpfcExpressionToInt(dimension_lower(d));
    *pmax = HpfcExpressionToInt(dimension_upper(d));
}

References array, array_distributed_p(), dimension_lower, dimension_upper, entity_ith_dimension(), entity_variable_p, HpfcExpressionToInt(), load_new_node(), and pips_assert.

Referenced by hpfc_compute_entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

get_ith_local_dummy()

entity get_ith_local_dummy

(

int

)

Referenced by clean_distributed_io_system(), generate_io_statements_for_shared_arrays(), hpfc_compute_entity_to_new_declaration(), hpfc_order_variables(), remapping_stats(), and remapping_variables().

Here is the caller graph for this function:

get_ith_local_prime()

entity get_ith_local_prime

(

int

)

Referenced by remapping_stats(), and remapping_variables().

Here is the caller graph for this function:

get_ith_processor_dummy()

entity get_ith_processor_dummy

(

int

)

Referenced by clean_distributed_io_system(), generate_remapping_code(), generate_work_sharing_system(), GENERATION(), hpfc_compute_distribute_constraints(), hpfc_hmessage(), hpfc_order_variables(), put_variables_in_ordered_lists(), and remapping_variables().

Here is the caller graph for this function:

get_ith_processor_prime()

entity get_ith_processor_prime

(

int

)

Referenced by broadcast(), generate_remapping_code(), generate_work_sharing_system(), and remapping_variables().

Here is the caller graph for this function:

get_ith_region_dummy()

entity get_ith_region_dummy

(

int

)

Referenced by clean_distributed_io_system(), clean_shared_io_system(), hpfc_unstutter_dummies(), and make_rectangular_area().

Here is the caller graph for this function:

get_ith_region_prime()

entity get_ith_region_prime

(

int

)

get_ith_shift_dummy()

entity get_ith_shift_dummy

(

int

)

Referenced by hpfc_compute_entity_to_new_declaration(), and hpfc_order_variables().

Here is the caller graph for this function:

get_ith_shift_prime()

entity get_ith_shift_prime

(

int

)

get_ith_template_dummy()

entity get_ith_template_dummy

(

int

)

Referenced by clean_distributed_io_system(), hpfc_compute_align_constraints(), hpfc_compute_distribute_constraints(), hpfc_compute_unicity_constraints(), and remapping_variables().

Here is the caller graph for this function:

get_ith_template_prime()

entity get_ith_template_prime

(

int

)

Referenced by remapping_variables().

Here is the caller graph for this function:

get_ith_temporary_dummy()

entity get_ith_temporary_dummy

(

int

)

Referenced by generate_remapping_code(), generate_work_sharing_system(), hpf_remapping(), hpfc_broadcast_buffers(), and remapping_variables().

Here is the caller graph for this function:

get_ith_temporary_prime()

entity get_ith_temporary_prime

(

int

)

get_maybeuseful_mappings()

statement_entities get_maybeuseful_mappings

(

void

)

Referenced by get_dynamic_status().

Here is the caller graph for this function:

get_new_host()

entitymap get_new_host

(

void

)

Referenced by get_entity_status().

Here is the caller graph for this function:

get_new_node()

entitymap get_new_node

(

void

)

Referenced by get_entity_status().

Here is the caller graph for this function:

get_old_host()

entitymap get_old_host

(

void

)

Referenced by get_entity_status().

Here is the caller graph for this function:

get_old_node()

entitymap get_old_node

(

void

)

Referenced by get_entity_status().

Here is the caller graph for this function:

get_only_io_map()

statement_mapping get_only_io_map

(

void

)

get_overlap()

int get_overlap	(	entity	ent,
		int	dim,
		int	side
	)

returns the overlap for a given entity, dimension and side, to be used in the declaration modifications

returns the overlap for a given entity, dimension and side, to be used in the declaration modifications

Parameters

ent	nt
dim	im
side	ide

Definition at line 743 of file declarations.c.

{
    overlap o;
 
    pips_assert("valid dimension", dim>0);
    pips_debug(10, "%s (DIM=%d) %s\n", entity_name(ent), dim, side?"+":"-");
 
    if (!bound_overlap_status_p(ent)) create_overlaps(ent);
    pips_assert("overlap ok", bound_overlap_status_p(ent));
 
    o = OVERLAP(gen_nth(dim-1, load_overlap_status(ent)));
    return(side ? overlap_upper(o) : overlap_lower(o));
}

References assert, bound_overlap_status_p(), create_overlaps(), entity_name, gen_nth(), load_overlap_status(), OVERLAP, overlap_lower, overlap_upper, pips_assert, and pips_debug.

Referenced by deal_with_similars(), declaration_with_overlaps(), and update_overlaps_of().

Here is the call graph for this function:

Here is the caller graph for this function:

get_overlap_status()

overlapsmap get_overlap_status

(

void

)

Referenced by init_hpfc_status(), and save_hpfc_status().

Here is the caller graph for this function:

get_primary_entity()

entitymap get_primary_entity

(

void

)

Referenced by get_dynamic_status().

Here is the caller graph for this function:

get_read_effect_area()

Psysteme get_read_effect_area	(	list	le,
		entity	var
	)

Parameters

le	e
var	ar

Definition at line 584 of file special_cases.c.

{
    MAP(EFFECT, e,
     {
         if (action_read_p(effect_action(e)) &&
             reference_variable(effect_any_reference(e))==var)
             return effect_system(e);
     },
         le);
 
    return SC_UNDEFINED;
}

References action_read_p, EFFECT, effect_action, effect_any_reference, effect_system, MAP, and reference_variable.

Referenced by make_rectangular_area().

Here is the caller graph for this function:

get_renamings()

statement_renamings get_renamings

(

void

)

Referenced by get_dynamic_status().

Here is the caller graph for this function:

get_similar_mapping()

entitymap get_similar_mapping

(

void

)

get_the_dynamics()

list get_the_dynamics

(

void

)

Referenced by handle_hpf_directives(), and initial_alignment().

Here is the caller graph for this function:

get_update_common_map()

entity_mapping get_update_common_map

(

void

)

GiveToHpfObjectsTheirNumber()

void GiveToHpfObjectsTheirNumber

(

void

)

give to hpf objects listed in distributedarrays, templates and processors their number for the code generation...

Definition at line 166 of file declarations.c.

{
    pips_debug(7, "Here I am!\n");
 
    MAP(ENTITY, e,
    {
        if (!bound_hpf_number_p(e))
            store_hpf_number(e, current_array_index++);
    },
        distributed_arrays);
 
    MAP(ENTITY, e,
    {
        if (!bound_hpf_number_p(e))
            store_hpf_number(e, current_template_index++);
    },
        templates);
 
    MAP(ENTITY, e,
    {
        if (!bound_hpf_number_p(e))
            store_hpf_number(e, current_processors_index++);
    },
        processors);
}

References bound_hpf_number_p(), current_array_index, current_processors_index, current_template_index, ENTITY, MAP, pips_debug, and store_hpf_number().

Referenced by NormalizeHpfDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

global_array_cell_to_local_array_cell()

int global_array_cell_to_local_array_cell	(	entity	array,
		int	dim,
		int	acell
	)

int global_array_cell_to_local_array_cell(array, dim, acell)

??? not enough general a function

Parameters

array	rray
dim	im
acell	cell

Definition at line 550 of file hpfc-util.c.

{
    alignment a = FindArrayDimAlignmentOfArray(array, dim);
    int rate, constant;
 
    pips_assert("aligned", a!=alignment_undefined);
 
    rate     = HpfcExpressionToInt(alignment_rate(a));
    constant = HpfcExpressionToInt(alignment_constant(a));
 
    return template_cell_local_mapping(array, dim, rate*acell+constant);
}

References alignment_constant, alignment_rate, alignment_undefined, array, FindArrayDimAlignmentOfArray, HpfcExpressionToInt(), pips_assert, and template_cell_local_mapping().

Referenced by shape_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_hpf_directives()

void handle_hpf_directives	(	statement	s,
		bool	dyn
	)

void handle_hpf_directives(s) statement s;

what: handles the HPF directives in statement s. how: recurses thru the AST, looking for special "directive calls". when found, a special handler is called for the given directive. input: the code statement s output: none side effects: (many)

• the hpfc data structures are set/updated to store the hpf mapping.
• parallel loops are tagged parallel.
• a static stack is used to retrieve the current statement.
• the ctrl_graph travelling is used, so should be initialized.
• the special calls are freed and replaced by continues. bugs or features:
• the "new" directive is not used to tag private variables.
• a non hpf "pure" directive is parsed.

INITIALIZE needed static stuff

PHASE 1

PHASE 2

PHASE 3

OPTIMIZATION

CLEAN

Parameters

dyn

yn

Definition at line 1069 of file directives.c.

{
    /* INITIALIZE needed static stuff
     */
    make_current_stmt_stack();
    to_be_cleaned = NIL;
 
    if (!dyn)
    {
    /* PHASE 1
     */
    pips_debug(1, "starting phase 1\n");
    analysis_phase = 1;
    gen_multi_recurse(s,
        statement_domain,  current_stmt_filter, current_stmt_rewrite,
        expression_domain, gen_false,           gen_null,
        call_domain,       directive_filter,    gen_null,
                      NULL);
    }
    else
    {
    /* PHASE 2
     */
    init_dynamic_locals();
    init_the_dynamics();
    store_renamings(s, NIL);
 
    pips_debug(1, "starting phase 2\n");
    analysis_phase = 2;
    gen_multi_recurse(s,
        statement_domain,  current_stmt_filter, current_stmt_rewrite, 
        call_domain,       prescription_filter, gen_null,
                      NULL);
 
    DEBUG_STAT(7, "between phase 2 and 3", s);
 
 
    /* PHASE 3
     */
    pips_debug(1, "starting phase 3\n");
    analysis_phase = 3;
    build_full_ctrl_graph(s);
    gen_multi_recurse(s,
        statement_domain,  current_stmt_filter, current_stmt_rewrite, 
        expression_domain, gen_false,           gen_null,
        call_domain,       directive_filter,    gen_null,
                      NULL);
 
    initial_alignment(s);
 
    ifdebug(7) dump_current_remapping_graph("after phase 3");
    DEBUG_STAT(7, "after phase 3", s);
 
    /* OPTIMIZATION
     */
    if (get_bool_property("HPFC_OPTIMIZE_REMAPPINGS"))
    {
        pips_debug(1, "starting optimization phase\n");
        simplify_remapping_graph();
    }
 
    clean_ctrl_graph();
 
    hpfc_check_for_similarities(get_the_dynamics());
 
    close_dynamic_locals();
    close_the_dynamics();
 
    DEBUG_STAT(7, "after optimization phase", s);
    }
 
    /* CLEAN
     */
    gen_map((gen_iter_func_t)clean_statement, to_be_cleaned);
    pips_assert("empty stack", current_stmt_empty_p());
    gen_free_list(to_be_cleaned), to_be_cleaned=NIL;
    free_current_stmt_stack();
 
    DEBUG_CODE(5, "resulting code", get_current_module_entity(), s);
}

References analysis_phase, build_full_ctrl_graph(), call_domain, clean_ctrl_graph(), clean_statement(), close_dynamic_locals(), close_the_dynamics(), DEBUG_CODE, DEBUG_STAT, directive_filter(), dump_current_remapping_graph(), expression_domain, gen_false(), gen_free_list(), gen_map(), gen_multi_recurse(), gen_null(), get_bool_property(), get_current_module_entity(), get_the_dynamics(), hpfc_check_for_similarities(), ifdebug, init_dynamic_locals(), init_the_dynamics(), initial_alignment(), NIL, pips_assert, pips_debug, prescription_filter(), simplify_remapping_graph(), statement_domain, store_renamings(), and to_be_cleaned.

Referenced by hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_hpf_reduction()

list handle_hpf_reduction

(

statement

s

)

of hpfc_reductions

of hpfc_reductions

Definition at line 274 of file special_cases.c.

{
    list /* of hpfc_reductions */ lr = NIL;
 
    MAP(ENTITY, e, 
        lr = CONS(HPFC_REDUCTIONS, reduction_of_in(e, s), lr),
        entities_list(load_hpf_reductions(s)));
 
    return lr;
}

References CONS, entities_list, ENTITY, HPFC_REDUCTIONS, load_hpf_reductions(), MAP, NIL, and reduction_of_in().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_alignment_undefined_p()

bool hpf_alignment_undefined_p

(

void

)

hpf_compiler()

void hpf_compiler	(	statement	stat,
		statement *	hoststatp,
		statement *	nodestatp
	)

what: compile a statement into a host and SPMD node code.

how: double code rewriting in a recursive traversal of stat. input: statement stat. output: statements *hoststatp and *nodestatp side effects: ? bugs or features:

• special care is made here of I/O and remappings.

of hpfc_reduction

necessary

remapping

HPF REDUCTION

else usual stuff

of statement

Parameters

stat	tat
hoststatp	oststatp
nodestatp	odestatp

Definition at line 710 of file compiler.c.

{
    list /* of hpfc_reduction */ lr = NIL;
    bool root_statement_p = stat==get_current_module_statement();
 
    DEBUG_STAT(9, "stat is", stat);
    pips_debug(9, "only io %d, remapping %d, reduction %d\n",
               load_statement_only_io(stat),
               bound_renamings_p(stat),
               bound_hpf_reductions_p(stat));
 
    if (load_statement_only_io(stat)==1) /* necessary */
    {
        io_efficient_compile(stat, hoststatp, nodestatp);
        return;
    }
    else if (bound_renamings_p(stat) && !root_statement_p) /* remapping */
    {
        remapping_compile(stat, hoststatp, nodestatp);
        return;
    }
    
    if (bound_hpf_reductions_p(stat)) /* HPF REDUCTION */
        lr = handle_hpf_reduction(stat);
    
    /* else usual stuff 
     */
    switch(instruction_tag(statement_instruction(stat)))
    {
    case is_instruction_block:
        hpf_compile_block(stat, hoststatp, nodestatp);
        break;
    case is_instruction_test:
        hpf_compile_test(stat, hoststatp, nodestatp);
        break;
    case is_instruction_loop:
        hpf_compile_loop(stat, hoststatp, nodestatp);
        break;
    case is_instruction_call:
        hpf_compile_call(stat, hoststatp, nodestatp);
        break;
    case is_instruction_unstructured:
        hpf_compile_unstructured(stat, hoststatp, nodestatp);
        break;
    case is_instruction_goto:
    default:
        pips_internal_error("unexpected instruction tag");
        break;
    }
 
    if (lr)
    {
        list /* of statement */ lh, ln;
        lh = gen_nconc(compile_hpf_reduction(lr, true, true),
         CONS(STATEMENT, *hoststatp,
                       compile_hpf_reduction(lr, false, true)));
        ln = gen_nconc(compile_hpf_reduction(lr, true, false),
         CONS(STATEMENT, *nodestatp,
                       compile_hpf_reduction(lr, false, false)));
 
        *hoststatp = make_block_statement(lh);
        *nodestatp = make_block_statement(ln);
    }
 
    if (root_statement_p && bound_renamings_p(stat))
    {
        *nodestatp = make_block_statement(
            CONS(STATEMENT, root_statement_remapping_inits(stat),
            CONS(STATEMENT, *nodestatp, NIL)));
    }
}

References bound_hpf_reductions_p(), bound_renamings_p(), compile_hpf_reduction(), CONS, DEBUG_STAT, gen_nconc(), get_current_module_statement(), handle_hpf_reduction(), hpf_compile_block(), hpf_compile_call(), hpf_compile_loop(), hpf_compile_test(), hpf_compile_unstructured(), instruction_tag, io_efficient_compile(), is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, load_statement_only_io(), make_block_statement(), NIL, pips_debug, pips_internal_error, remapping_compile(), root_statement_remapping_inits(), STATEMENT, and statement_instruction.

Referenced by compile_control(), compile_module(), hpf_compile_block(), hpf_compile_sequential_loop(), hpf_compile_test(), and hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_distribution_undefined_p()

bool hpf_distribution_undefined_p

(

void

)

hpf_number_undefined_p()

bool hpf_number_undefined_p

(

void

)

hpf_pure_p()

bool hpf_pure_p

(

entity

f

)

??? some intrinsics should also be considered as pure.

all of them ?

Definition at line 67 of file hpfc.c.

{ return gen_in_list_p(f, the_pures_object);}

References f(), and gen_in_list_p().

Referenced by hpfc_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

hpf_reductions_undefined_p()

bool hpf_reductions_undefined_p

(

void

)

hpfc.c

hpfc_add_2()

statement hpfc_add_2

(

expression

exp

)

expr = expr + 2

Parameters

exp

xp

Definition at line 141 of file generate-util.c.

{
    entity plus = entity_intrinsic(PLUS_OPERATOR_NAME);
    return(make_assign_statement
           (copy_expression(exp), 
            MakeBinaryCall(plus, exp, int_to_expression(2))));
 
}

References copy_expression(), entity_intrinsic(), exp, int_to_expression(), make_assign_statement(), MakeBinaryCall(), and PLUS_OPERATOR_NAME.

Referenced by hpfc_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_add_ahead_of_node_code()

void hpfc_add_ahead_of_node_code

(

statement

s

)

Definition at line 404 of file hpfc.c.

{
  added_ahead_of_node_code = CONS(STATEMENT, s, added_ahead_of_node_code);
}

References added_ahead_of_node_code, CONS, and STATEMENT.

Referenced by generate_optimized_code_for_loop_nest().

Here is the caller graph for this function:

hpfc_add_n()

statement hpfc_add_n	(	entity	var,
		int	n
	)

returns statement VAR = VAR + N

added value

Parameters

var	ar
n	integer scalar variable

Definition at line 128 of file generate-util.c.

{
    return make_assign_statement
        (entity_to_expression(var),
         MakeBinaryCall(entity_intrinsic(PLUS_OPERATOR_NAME),
                        entity_to_expression(var), int_to_expression(n)));
}

References entity_intrinsic(), entity_to_expression(), int_to_expression(), make_assign_statement(), MakeBinaryCall(), and PLUS_OPERATOR_NAME.

Referenced by hpfc_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_algorithm_row_echelon()

void hpfc_algorithm_row_echelon	(	Psysteme	syst,
		list	scanners,
		Psysteme *	pcond,
		Psysteme *	penum
	)

io-compile.c

this should improve conditions?

Parameters

syst	yst
scanners	canners
pcond	cond
penum	enum

Definition at line 127 of file io-compile.c.

{
    Pbase base = entity_list_to_base(scanners);
    algorithm_row_echelon_generic(syst, base, pcond, penum,
        get_bool_property("HPFC_REDUNDANT_SYSTEMS_FOR_REMAPS"));
    /* this should improve conditions? */
    sc_find_equalities(pcond);
    base_rm(base);
}

References algorithm_row_echelon_generic(), base, base_rm, entity_list_to_base(), get_bool_property(), and sc_find_equalities().

Referenced by generate_io_collect_or_update(), hpf_remapping(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_algorithm_tiling()

void hpfc_algorithm_tiling	(	Psysteme	syst,
		list	processors,
		list	scanners,
		Psysteme *	pcondition,
		Psysteme *	pproc_echelon,
		Psysteme *	ptile_echelon
	)

Parameters

syst	yst
processors	rocessors
scanners	canners
pcondition	condition
pproc_echelon	proc_echelon
ptile_echelon	tile_echelon

Definition at line 689 of file io-compile.c.

{
    Pbase
        outer = entity_list_to_base(processors),
        inner = entity_list_to_base(scanners);
 
    DEBUG_SYST(8, "initial system", syst);
 
    algorithm_tiling(syst, outer, inner, 
                     pcondition, pproc_echelon, ptile_echelon);
 
    DEBUG_SYST(3, "condition", *pcondition);
    DEBUG_BASE(3, "proc vars", outer);
    DEBUG_SYST(3, "processors", *pproc_echelon);
    DEBUG_BASE(3, "tile vars", inner);
    DEBUG_SYST(3, "tiles", *ptile_echelon);
 
    base_rm(outer);
    base_rm(inner);
}

References algorithm_tiling(), base_rm, DEBUG_BASE, DEBUG_SYST, and entity_list_to_base().

Referenced by generate_io_collect_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_array_bound()

expression hpfc_array_bound	(	entity	array,
		bool	upper,
		int	dim
	)

Parameters

array	rray
upper	pper
dim	im

Definition at line 516 of file run-time.c.

{
    /*
    return entity_to_expression
        (argument_bound_entity(node_module, array, upper, dim)); 
        */
    return MakeCharacterConstantExpression(bound_parameter_name(array, 
                         upper?UPPER:LOWER, dim));
}

References array, bound_parameter_name(), LOWER, MakeCharacterConstantExpression(), and UPPER.

Referenced by array_bounds_list(), caller_list_of_bounds(), and declaration_with_overlaps().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_broadcast_if_necessary()

statement hpfc_broadcast_if_necessary	(	entity	array,
		entity	trg,
		entity	lid,
		entity	proc,
		bool	is_lazy
	)

lazy or not...

Parameters

array	rray
trg	rg
lid	id
proc	roc
is_lazy	s_lazy

Definition at line 404 of file generate-util.c.

{
    expression not_empty;
    statement send, pack;
 
    not_empty = buffer_full_condition(array, true, false);
    send = hpfc_broadcast_buffers(array, trg, lid, proc);
    pack = hpfc_packing_of_current__buffer(array, true);
 
    if (is_lazy)
        return test_to_statement
            (make_test(not_empty,
             make_block_statement(CONS(STATEMENT, pack,
                                  CONS(STATEMENT, send, NIL))),
             make_continue_statement(entity_undefined)));
    else
        return make_block_statement
            (CONS(STATEMENT, test_to_statement(make_test(not_empty, pack,
                             make_continue_statement(entity_undefined))),
             CONS(STATEMENT, test_to_statement(make_test(not_expression
                (entity_to_expression(hpfc_name_to_entity(SND_NOT_INIT))),send,
                             make_continue_statement(entity_undefined))),
                  NIL)));
}

References array, buffer_full_condition(), CONS, entity_to_expression(), entity_undefined, hpfc_broadcast_buffers(), hpfc_name_to_entity(), hpfc_packing_of_current__buffer(), make_block_statement(), make_continue_statement(), make_test(), NIL, not_expression, SND_NOT_INIT, STATEMENT, and test_to_statement.

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_buffer_initialization()

statement hpfc_buffer_initialization	(	bool	,
		bool	,
		bool
	)

hpfc_buffer_packing()

statement hpfc_buffer_packing	(	entity	,
		entity(*)(void)	,
		bool
	)

hpfc_buffer_reference()

expression hpfc_buffer_reference	(	entity	array,
		entity	index
	)

returns a reference to the typed common hpfc_buffer buffer, that suits array basic type and with index as an index.

index variable

Parameters

array	rray
index	array to select the right typed buffer

Definition at line 267 of file generate-util.c.

{
    return reference_to_expression
        (make_reference(hpfc_buffer_entity(array, BUFFER),
         CONS(EXPRESSION, entity_to_expression(index), 
              NIL)));
}

References array, BUFFER, CONS, entity_to_expression(), EXPRESSION, hpfc_buffer_entity(), make_reference(), NIL, and reference_to_expression().

Referenced by hpfc_buffer_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_call_with_distributed_args_p()

bool hpfc_call_with_distributed_args_p

(

call

c

)

whether call c inplies a distributed argument

no intrinsics

else checks for distributed arguments

Definition at line 645 of file dynamic.c.

{
    entity f = call_function(c);
    int len = gen_length(call_arguments(c));
 
    /* no intrinsics */
    if (value_intrinsic_p(entity_initial(f)) ||
        hpf_directive_entity_p(f)) return false;
    
    /* else checks for distributed arguments */
    for (; len>0; len--)
    {
        entity arg = find_ith_parameter(f, len);
        if (array_distributed_p(arg)) return true;
    }
 
    return false;
}

References array_distributed_p(), call_arguments, call_function, entity_initial, f(), find_ith_parameter(), gen_length(), hpf_directive_entity_p(), and value_intrinsic_p.

Referenced by prescription_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_check_for_similarities()

void hpfc_check_for_similarities

(

list

le

)

check all dynamic arrays for some similars...

of entity

similar bases

Parameters

le

e

Definition at line 269 of file dynamic.c.

{
    MAP(ENTITY, array,
    {
        if (array_distributed_p(array))
        {
            list /* of entity */ 
                seens = CONS(ENTITY, array, NIL); /* similar bases */
            
            pips_assert("is a primary!", primary_entity_p(array));
            
            check_for_similarity(array, NIL);
            
            MAP(ENTITY, a,
            {
                if (!gen_in_list_p(a, seens))
                {
                    entity similar;
                    check_for_similarity(a, seens);
                    similar = load_similar_mapping(a);
                    pips_debug(1, "%s similar to %s\n",
                               entity_name(a), entity_name(similar));
                    
                    seens = gen_once(similar, seens);
                }
            },
                entities_list(load_dynamic_hpf(array)));
            
            gen_free_list(seens);
        }
    },
        le);
}

References array, array_distributed_p(), check_for_similarity(), CONS, entities_list, ENTITY, entity_name, gen_free_list(), gen_in_list_p(), gen_once(), load_dynamic_hpf(), load_similar_mapping(), MAP, NIL, pips_assert, pips_debug, and primary_entity_p.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_close()

bool hpfc_close

(

const string

name

)

bool hpfc_close(string name)

what: closes the hpf compiler execution. to be called by pipsmake. input: the program (workspace) name. output: none. side effects:

• deals with the commons.
• generates global files. bugs or features:
• ??? COMMON should be managable thru pipsmake ad-hoc rules.

global informations

not close, because it would free the memory and pipsdbm will run into troubles when trying to free the resource...

??? the next function is in pipsmake... (should be in pipsdbm only, but pipsmake manages its own cache which must be destroyed also...

fake

Parameters

name

ame

Definition at line 798 of file hpfc.c.

{
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering program %s\n", name);
  reset_hooks_register(hpfc_error_handler);
 
  load_hpfc_status();
 
  set_string_property("PRETTYPRINT_COMMONS", "declaration");
  set_string_property("PIPSDBM_RESOURCES_TO_DELETE", "all");
  gen_map((gen_iter_func_t)compile_common, get_the_commons());
 
  put_generated_resources_for_program(name);      /* global informations */
 
  /* not close, because it would free the memory and
   * pipsdbm will run into troubles when trying to free the resource...
   */
  save_hpfc_status();
 
  /* ??? the next function is in pipsmake... (should be in pipsdbm only,
   * but pipsmake manages its own cache which must be destroyed also...
   */
  DB_PUT_FILE_RESOURCE(DBR_HPFC_COMMONS, name, NO_FILE); /* fake */
 
  reset_hooks_unregister(hpfc_error_handler);
  debug_off();
  return true;
}

References compile_common(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, gen_map(), hpfc_error_handler(), load_hpfc_status(), NO_FILE, pips_debug, put_generated_resources_for_program(), reset_hooks_register(), reset_hooks_unregister(), save_hpfc_status(), and set_string_property().

Here is the call graph for this function:

hpfc_close_dummy_to_prime()

void hpfc_close_dummy_to_prime

(

void

)

Definition at line 168 of file build-system.c.

{
    close_dummy_to_prime();
}

Referenced by compile_module().

Here is the caller graph for this function:

hpfc_common()

bool hpfc_common

(

const string

name

)

bool hpfc_common(string name)

what: compile a common, that is generate the common for both host and nodes. how: generate files to be included. input: a common name. output: none. side effects:

• uses the hpfc_status.
• generates 4 files. bugs or features:
• never called by pipsmake (:-)

Parameters

name

ame

Definition at line 769 of file hpfc.c.

{
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering common %s\n", name);
  reset_hooks_register(hpfc_error_handler);
 
  load_hpfc_status();
 
  set_string_property("PRETTYPRINT_COMMONS", "declaration");
  compile_common(local_name_to_top_level_entity(name));
 
  save_hpfc_status();
 
  reset_hooks_unregister(hpfc_error_handler);
  debug_off();
  return true;
}

References compile_common(), debug_off, debug_on, hpfc_error_handler(), load_hpfc_status(), local_name_to_top_level_entity(), pips_debug, reset_hooks_register(), reset_hooks_unregister(), save_hpfc_status(), and set_string_property().

Here is the call graph for this function:

hpfc_compile()

bool hpfc_compile

(

const string

name

)

bool hpfc_compile(string name)

what: hpf compile module name. to be called by pipsmake. input: the name of the module to compile. output: none side effects: (many)

• creates the statements for the host and nodes.
• store the generated resources. bugs or features:
• fortran library, reduction and hpfc special functions are skipped.
• a fake file is put as the generated resource for such modules.

just fake for pipsmake...

for callers

Parameters

name

ame

Definition at line 699 of file hpfc.c.

{
  entity module = module_name_to_entity(name);
  bool do_compile;
 
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", name);
  reset_hooks_register(hpfc_error_handler);
 
  load_hpfc_status();
  set_current_module_entity(module);
 
  do_compile =
    !hpfc_entity_reduction_p(module) &&
    !hpf_directive_entity_p(module) &&
    !fortran_library_entity_p(module) &&
    !hpfc_special_fake(module);
 
  if (do_compile)
  {
    set_string_property("PRETTYPRINT_COMMONS", "none");
 
    if (hpfc_special_io(module))
            compile_a_special_io_function(module);
    else if (hpf_pure_p(module))
            compile_a_pure_function(module);
    else
            compile_module(module);
  }
  else /* just fake for pipsmake... */
  {
    pips_debug(2, "skipping %s compilation\n", name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_PARAMETERS, name, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_HOST, name, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_NODE, name, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_RTINIT, name, NO_FILE);
  }
 
  /* for callers */
  if (hpfc_special_io(module))
  {
    store_new_host_variable(module, module);
    store_new_node_variable(entity_intrinsic(CONTINUE_FUNCTION_NAME), module);
  }
  else if (hpf_pure_p(module))
  {
    store_new_host_variable(module, module);
    store_new_node_variable(module, module);
  }
 
  reset_current_module_entity();
  save_hpfc_status();
 
  reset_hooks_unregister(hpfc_error_handler);
  debug_off();
  return true;
}

References compile_a_pure_function(), compile_a_special_io_function(), compile_module(), CONTINUE_FUNCTION_NAME, DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_intrinsic(), fortran_library_entity_p(), hpf_directive_entity_p(), hpf_pure_p(), hpfc_entity_reduction_p(), hpfc_error_handler(), hpfc_special_fake(), hpfc_special_io(), load_hpfc_status(), module, module_name_to_entity(), NO_FILE, pips_debug, reset_current_module_entity(), reset_hooks_register(), reset_hooks_unregister(), save_hpfc_status(), set_current_module_entity(), set_string_property(), store_new_host_variable(), and store_new_node_variable().

Here is the call graph for this function:

hpfc_compile_error_handler()

void hpfc_compile_error_handler

(

void

)

Definition at line 644 of file compile.c.

{
    error_reset_c_stmt_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

hpfc_compute_entity_to_new_declaration()

Psysteme hpfc_compute_entity_to_new_declaration

(

entity

array

)

LALPHAi == ALPHAi

LALPHAi = ALPHAi - ALPHAi_min + 1

(|a|==1) LALPHA_i == DELTA_j + 1 generalized to: (|a|!=1) |a| * (LALPHA_i - 1) + IOTA_j == DELTA_j 0 <= IOTA_j < |a|

IOTA is not needed

LALPHA_i == N* (GAMMA_j - GAMMA_0) + DELTA_j + 1

LALPHA_i = iceil(N,|a|) * (GAMMA_j - GAMMA_0) + SIGMA_j +1 DELTA_j = |a|*SIGMA_j + IOTA_j 0 <= IOTA_j < |a|

Parameters

array

rray

Definition at line 533 of file build-system.c.

{
    int dim = NumberOfDimension(array);
    Psysteme syst = sc_rn(NULL);
 
    pips_assert("distributed array", array_distributed_p(array));
 
    for (; dim>0; dim--)
    {
         entity lalpha = get_ith_local_dummy(dim),
                alpha = get_ith_array_dummy(dim);
 
         switch (new_declaration_tag(array, dim))
         {
         case is_hpf_newdecl_none:
             /* LALPHAi == ALPHAi
              */
             sc_add_egalite
                 (syst, 
                  contrainte_make(vect_make(VECTEUR_NUL,
                                            alpha,      VALUE_ONE,
                                            lalpha,     VALUE_MONE,
                                            TCST,       VALUE_ZERO)));
             break;
         case is_hpf_newdecl_alpha:
         {
             /* LALPHAi = ALPHAi - ALPHAi_min + 1
              */
             int min = 314159;
             int max = -314159;
 
             get_ith_dim_new_declaration(array, dim, &min, &max);
             
             sc_add_egalite
                 (syst,
                  contrainte_make(vect_make(VECTEUR_NUL,
                                            alpha,      VALUE_ONE,
                                            lalpha,     VALUE_MONE,
                                            TCST,       int_to_value(1-min))));
 
             break;
         }
         case is_hpf_newdecl_beta:
         {
             /* (|a|==1) LALPHA_i == DELTA_j + 1
              * generalized to:
              * (|a|!=1) |a| * (LALPHA_i - 1) + IOTA_j == DELTA_j
              *           0 <= IOTA_j < |a|
              */
             entity delta, template = array_to_template(array);
             int tdim, pdim, a, b, n;
             
             get_alignment(array, dim, &tdim, &a, &b);
             pips_assert("aligned dimension", a!=0 && tdim!=0);
             get_distribution(template, tdim, &pdim, &n);
             
             delta = get_ith_block_dummy(pdim);
 
             if (abs(a)==1)
             {
                 /* IOTA is not needed */
                 sc_add_egalite(syst,
                   contrainte_make(vect_make(VECTEUR_NUL,
                                             delta,     VALUE_ONE,
                                             lalpha,    VALUE_MONE,
                                             TCST,      VALUE_ONE)));
             }
             else
             {
                 entity iota = get_ith_shift_dummy(pdim);
                 Pvecteur
                     v1 = vect_make(VECTEUR_NUL,
                                    (Variable) lalpha,  int_to_value(abs(a)),
                                    (Variable) iota,    VALUE_ONE,
                                    (Variable) delta,   VALUE_MONE,
                                    TCST,       int_to_value(-abs(a)));
 
                 sc_add_egalite(syst, contrainte_make(v1));
                 sc_add_inegalite(syst,
                                  contrainte_make(vect_new((Variable) iota, 
                                                           VALUE_MONE)));
                 sc_add_inegalite
                     (syst,
                      contrainte_make(vect_make(VECTEUR_NUL,
                             (Variable) iota, VALUE_ONE,
                              TCST,     int_to_value(-(abs(a)-1)))));
             }
 
             break;
         }
         case is_hpf_newdecl_gamma:
         {
             /* LALPHA_i == N* (GAMMA_j - GAMMA_0) + DELTA_j + 1
              */
             entity
                 gamma = entity_undefined,
                 delta = entity_undefined,
                 template = array_to_template(array),
                 processor = template_to_processors(template);
             int gamma_0 = 0, tdim = -1, pdim = -1, a = 0, b = 0,
                 n, plow, pup, tlow, tup, alow, aup;
             
             get_alignment(array, dim, &tdim, &a, &b);
             pips_assert("stride-1 aligned", abs(a)==1 && tdim!=0);
             
             get_distribution(template, tdim, &pdim, &n);
             pips_assert("distributed dimension", pdim>0 && n>0);
             
             get_entity_dimensions(array, dim, &alow, &aup);
             get_entity_dimensions(template, tdim, &tlow, &tup);
             get_entity_dimensions(processor, pdim, &plow, &pup);
 
             delta = get_ith_block_dummy(pdim);
             gamma = get_ith_cycle_dummy(pdim);
 
             gamma_0 = (a*alow + b - tlow) % (n * (pup - plow + 1));
 
             sc_add_egalite
                 (syst,
                  contrainte_make(vect_make
                    (VECTEUR_NUL,
                     delta,     VALUE_ONE,
                     gamma,     int_to_value(n),
                     lalpha,    VALUE_MONE,
                     TCST,      int_to_value(1-(n*gamma_0)))));
             break;
         }
         case is_hpf_newdecl_delta:
         {
             /* LALPHA_i = iceil(N,|a|) * (GAMMA_j - GAMMA_0) + SIGMA_j +1
              * DELTA_j = |a|*SIGMA_j + IOTA_j
              * 0 <= IOTA_j < |a|
              */
             entity sigma = entity_undefined,
                 iota = entity_undefined,
                 gamma = entity_undefined,
                 delta = entity_undefined,
                 template = array_to_template(array),
                 processor = template_to_processors(template);
             int gamma_0 = 0, tdim = -1, pdim = -1, a = 0, b = 0,
                 n, icn, plow, pup, tlow, tup, alow, aup;
             
             get_alignment(array, dim, &tdim, &a, &b);
             pips_assert("aligned dimension", tdim!=0);
             
             get_distribution(template, tdim, &pdim, &n);
             pips_assert("distributed dimension", pdim>0 && n>0);
             
             get_entity_dimensions(array, dim, &alow, &aup);
             get_entity_dimensions(template, tdim, &tlow, &tup);
             get_entity_dimensions(processor, pdim, &plow, &pup);
 
             sigma = get_ith_auxiliary_dummy(pdim);
             iota = get_ith_shift_dummy(pdim);
             delta = get_ith_block_dummy(pdim);
             gamma = get_ith_cycle_dummy(pdim);
 
             gamma_0 = (a*alow + b - tlow) % (n * (pup - plow + 1));
             icn = iceil(n, abs(a));
 
             sc_add_egalite
                 (syst,
                  contrainte_make
                  (vect_make(VECTEUR_NUL,
                             sigma,     VALUE_ONE,
                             gamma,     int_to_value(icn),
                             lalpha,    VALUE_MONE,
                             TCST,      int_to_value(1-(icn*gamma_0)))));
 
             sc_add_egalite
                 (syst,
                  contrainte_make
                  (vect_make(VECTEUR_NUL,
                             delta,     VALUE_ONE,
                             sigma,     int_to_value(-abs(a)),
                             iota,      VALUE_MONE,
                             TCST,      VALUE_ZERO)));
 
             sc_add_inegalite(syst,
                              contrainte_make(vect_new((Variable) iota, 
                                                       VALUE_MONE)));
             sc_add_inegalite
                 (syst,
                  contrainte_make
                  (vect_make(VECTEUR_NUL,
                             (Variable) iota, VALUE_ONE,
                             TCST,      int_to_value(-(abs(a)-1)))));
             break;
         }
         default:
             pips_internal_error("unexpected new declaration tag");
         }
     }
    
    sc_creer_base(syst);
    return syst;
}

References abs, array, array_distributed_p(), array_to_template, contrainte_make(), entity_undefined, get_alignment(), get_distribution(), get_entity_dimensions(), get_ith_array_dummy(), get_ith_auxiliary_dummy(), get_ith_block_dummy(), get_ith_cycle_dummy(), get_ith_dim_new_declaration(), get_ith_local_dummy(), get_ith_shift_dummy(), iceil, int_to_value, is_hpf_newdecl_alpha, is_hpf_newdecl_beta, is_hpf_newdecl_delta, is_hpf_newdecl_gamma, is_hpf_newdecl_none, max, min, new_declaration_tag(), NumberOfDimension(), pips_assert, pips_internal_error, sc_add_egalite(), sc_add_inegalite(), sc_creer_base(), sc_rn(), TCST, template_to_processors, VALUE_MONE, VALUE_ONE, VALUE_ZERO, vect_make(), vect_new(), and VECTEUR_NUL.

Referenced by entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compute_lid()

statement hpfc_compute_lid	(	entity	,
		entity	,
		entity(*)(void)	,
		entity
	)

hpfc_compute_unicity_constraints()

Psysteme hpfc_compute_unicity_constraints

(

entity

e

)

Psysteme hpfc_compute_unicity_constraints(e) entity e should be an array;.

equations for non aligned template dimensions are computed: ???

theta_i - lower_template_i == 0

Definition at line 360 of file build-system.c.

{
    align al = load_hpf_alignment(e);
    entity template = align_template(al);
    Psysteme new_system = sc_new();
    int i;
 
    pips_assert("distributed array", array_distributed_p(e));
 
    for(i=1 ; i<=NumberOfDimension(template) ; i++)
    {
        alignment
            a = FindAlignmentOfTemplateDim(align_alignment(al), i);
        
        if (a==alignment_undefined)
        {
            entity
                theta = get_ith_template_dummy(i);
            int
                low = 
                    HpfcExpressionToInt
                        (dimension_lower(entity_ith_dimension(template, i)));
 
            sc_add_egalite
                (new_system,
                 contrainte_make(vect_make(VECTEUR_NUL,
                                           theta,       VALUE_ONE,
                                           TCST,        int_to_value(-low))));
        }
    }
    sc_creer_base(new_system);
    return(new_system);
}

References align_alignment, align_template, alignment_undefined, array_distributed_p(), contrainte_make(), dimension_lower, entity_ith_dimension(), FindAlignmentOfTemplateDim(), get_ith_template_dummy(), HpfcExpressionToInt(), int_to_value, load_hpf_alignment(), NumberOfDimension(), pips_assert, sc_add_egalite(), sc_creer_base(), sc_new(), TCST, VALUE_ONE, vect_make(), and VECTEUR_NUL.

Referenced by generate_distributed_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_current_statement_undefined_p()

bool hpfc_current_statement_undefined_p

(

void

)

align-checker.c

hpfc_directives_error_handler()

void hpfc_directives_error_handler

(

void

)

the local stack is used to retrieve the current statement while scanning the AST with gen_recurse.

Definition at line 109 of file directives.c.

{
  error_reset_current_stmt_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

hpfc_dynamic_directives()

bool hpfc_dynamic_directives

(

const

string

)

Parameters

string

ame

Definition at line 681 of file hpfc.c.

{
  return hpfc_directives_handler(name, true);
}

References hpfc_directives_handler().

Here is the call graph for this function:

hpfc_entity_reduction_p()

bool hpfc_entity_reduction_p

(

entity

e

)

special_cases.c

special_cases.c

true if a given call is a call to reduction function. ??? a generic function name should be managed here?

Definition at line 82 of file special_cases.c.

{
    return find_reduction(module_local_name(e)) != NULL;
}

References find_reduction(), and module_local_name().

Referenced by call_reduction_p(), hpfc_compile(), and hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_fclose()

void hpfc_fclose	(	FILE *	f,
		string	name
	)

Parameters

name

ame

Definition at line 341 of file compile.c.

{
    string base = pips_basename(name, NULL);
    fprintf(f, "!\n! That is all for %s\n!\n", base);
    free(base);
    safe_fclose(f, name);
}

References base, f(), fprintf(), free(), pips_basename(), and safe_fclose().

Referenced by generate_hpf_remapping_file(), put_generated_resources_for_common(), put_generated_resources_for_module(), and put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_filter()

bool hpfc_filter

(

const

string

)

Parameters

string

ame

Definition at line 594 of file hpfc.c.

{
  string file_name, dir_name, new_name, src_name;
 
  dir_name = db_get_current_workspace_directory();
  file_name = db_get_file_resource(DBR_SOURCE_FILE, name, true);
  new_name = strdup(concatenate(name, HPFC_FILTERED_SUFFIX, NULL));
  src_name = strdup(concatenate(dir_name, "/", file_name, NULL));
 
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", name);
  reset_hooks_register(hpfc_error_handler);
 
  safe_system(concatenate(
                "PATH=${PATH}:${PIPS_ROOT}/Share ",
                hpf_directive_string_p(name) || !directive_in_file_p(src_name)?
                "cat" : "hpfc_directives",
                " < ", src_name, " > ", dir_name, "/", new_name, NULL));
 
  DB_PUT_FILE_RESOURCE(DBR_HPFC_FILTERED_FILE, name, new_name);
 
  free(src_name);
 
  reset_hooks_unregister(hpfc_error_handler);
  debug_off();
  return true;
}

References concatenate(), db_get_current_workspace_directory(), db_get_file_resource, DB_PUT_FILE_RESOURCE, debug_off, debug_on, directive_in_file_p(), file_name, free(), hpf_directive_string_p(), hpfc_error_handler(), HPFC_FILTERED_SUFFIX, pips_debug, reset_hooks_register(), reset_hooks_unregister(), safe_system(), and strdup().

Here is the call graph for this function:

hpfc_fopen()

FILE* hpfc_fopen

(

string

name

)

Parameters

name

ame

Definition at line 329 of file compile.c.

{
    string base = pips_basename(name, NULL);
    FILE *f = (FILE *) safe_fopen(name, "w");
    fprintf(f, "!\n! File %s\n! This file has been automatically generated " 
            "by the HPF compiler\n!\n", base);
    free(base);
    return f;
}

References base, f(), fprintf(), free(), pips_basename(), and safe_fopen().

Referenced by generate_hpf_remapping_file(), put_generated_resources_for_common(), put_generated_resources_for_module(), and put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_gen_n_vars_expr()

list hpfc_gen_n_vars_expr	(	entity(*)(void)	,
		int
	)

hpfc_generate_message()

statement hpfc_generate_message	(	entity	ld,
		bool	send,
		bool	lazy
	)

Parameters

ld	d
send	end
lazy	azy

Definition at line 208 of file generate-util.c.

{
    entity nc, nt;
    expression lid, tid, chn;
 
    nc = hpfc_name_to_entity(send ? SEND_CHANNELS : RECV_CHANNELS);
    nt = hpfc_name_to_entity(NODETIDS);
    lid = entity_to_expression(ld);
    tid = reference_to_expression
        (make_reference(nt, CONS(EXPRESSION, lid, NIL)));
    chn = reference_to_expression
        (make_reference(nc, CONS(EXPRESSION, copy_expression(lid), NIL)));
 
    return lazy ? hpfc_lazy_message(tid, chn, send) : 
                  hpfc_message(tid, chn, send);
}

References CONS, copy_expression(), entity_to_expression(), EXPRESSION, hpfc_lazy_message(), hpfc_message(), hpfc_name_to_entity(), make_reference(), NIL, NODETIDS, RECV_CHANNELS, reference_to_expression(), and SEND_CHANNELS.

Referenced by broadcast(), gen(), and hpfc_lazy_packing().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_init()

bool hpfc_init

(

const string

name

)

bool hpfc_init(string name)

what: initialize the hpfc status for a program. input: the program (workspace) name. output: none. side effects:

• the hpfc status is initialized and stored in the pips dbm. bugs or features:
• some callees are filtered out with a property, to deal with pipsmake.

vars local to commons

drop hpfc specials

Parameters

name

ame

Definition at line 503 of file hpfc.c.

{
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering program %s\n", name);
 
  reset_hooks_register(hpfc_error_handler);
 
  set_string_property("PRETTYPRINT_VARIABLE_DIMENSIONS", "common");
  set_bool_property("PRETTYPRINT_HPFC", true); /* vars local to commons */
  set_bool_property("HPFC_FILTER_CALLEES", true); /* drop hpfc specials */
  set_bool_property("GLOBAL_EFFECTS_TRANSLATION", false);
  set_bool_property("WARNING_ON_STAT_ERROR", false); // for fake files
 
  // should not be there. if true, obscure coredump in proper
  // effects on a preference which has been cleanup up...
  // see validation/Hpfc/io_4.tpips that triggers the issue
  set_bool_property("PRETTYPRINT_IO_EFFECTS", false); // ??????
 
  // too verbose...
  set_bool_property("UNSPAGHETTIFY_DISPLAY_STATISTICS", false);
  set_bool_property("CLEAN_UP_SEQUENCES_DISPLAY_STATISTICS", false);
  set_bool_property("WARN_ABOUT_EMPTY_SEQUENCES", false);
 
  // where the specials dummy/variables are stored... ???
  (void) make_empty_program(HPFC_PACKAGE,make_language_fortran());
 
  // mkdir...
  {
    string dir_name = db_get_directory_name_for_module(WORKSPACE_SRC_SPACE);
    free(dir_name);
  }
 
  init_hpfc_status();
  save_hpfc_status();
 
  reset_hooks_unregister(hpfc_error_handler);
  debug_off();
  return true;
}

References db_get_directory_name_for_module(), debug_off, debug_on, free(), hpfc_error_handler(), HPFC_PACKAGE, init_hpfc_status(), make_empty_program(), make_language_fortran(), pips_debug, reset_hooks_register(), reset_hooks_unregister(), save_hpfc_status(), set_bool_property(), set_string_property(), and WORKSPACE_SRC_SPACE.

Here is the call graph for this function:

hpfc_init_dummy_to_prime()

void hpfc_init_dummy_to_prime

(

void

)

Definition at line 155 of file build-system.c.

{
    init_dummy_to_prime();
    STORE(array);
    STORE(template);
    STORE(processor);
    STORE(block);
    STORE(cycle);
    STORE(local);
    STORE(shift);
    STORE(auxiliary);
}

References array, and STORE.

Referenced by compile_module().

Here is the caller graph for this function:

hpfc_init_run_time_entities()

void hpfc_init_run_time_entities

(

void

)

to be seen from outside of this file

they are declared as variables to avoid redefinitions ??? this fools pips typing (functions/variables and so) just okay for the pretty printer...

why not

dimensions are updated

Definition at line 751 of file run-time.c.

{
    RunTimeSupportDescriptor *current;
    int i=0;
    list l=NIL;
 
    if (RTSTable_initialized_p) return;
    RTSTable_initialized_p = true;
 
    for(current=RTSTable;
        current->what!=is_end;
        current++)
    {
        pips_debug(6, "initializing %s, %d\n", current->name, current->arity);
 
        switch(current->what)
        {
        case is_fun:
            current->object = MakeRunTimeSupportFunction(current->name, 
                                                         current->arity,
                                                         current->basic);
            break;
        case is_sub:
            current->object = MakeRunTimeSupportSubroutine(current->name, 
                                                           current->arity);
            break;
        case is_ifn: 
            /* they are declared as variables to avoid redefinitions 
             * ??? this fools pips typing (functions/variables and so)
             * just okay for the pretty printer...
             */
        case is_iof:
        case is_var:
            current->object = 
                find_or_create_typed_entity(current->name,
                                            HPFC_PACKAGE, /* why not */
                                            current->basic);
            /* dimensions are updated
             */
            l = NIL;
            for(i=1; i<=current->arity; i++)
                l = CONS(DIMENSION,
                         make_dimension(int_to_expression(1),
                                        int_to_expression(1),
                                        NIL),
                         l);
            variable_dimensions
                (type_variable(entity_type(current->object))) = l;
            break;
        default:
            pips_internal_error("unexpected what field in Descriptor");
        }    
    }
}

References CONS, current, DIMENSION, entity_type, find_or_create_typed_entity(), HPFC_PACKAGE, int_to_expression(), is_end, is_fun, is_ifn, is_iof, is_sub, is_var, make_dimension(), MakeRunTimeSupportFunction(), MakeRunTimeSupportSubroutine(), NIL, pips_debug, pips_internal_error, RTSTable, RTSTable_initialized_p, type_variable, and variable_dimensions.

Referenced by hpfc_directives_handler(), and set_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_initsend()

statement hpfc_initsend

(

bool

lazy

)

2 args to pvmfinitsend

Parameters

lazy

azy

Definition at line 229 of file generate-util.c.

{
    statement init;
 
    /* 2 args to pvmfinitsend
     */
    init = hpfc_make_call_statement
             (hpfc_name_to_entity(PVM_INITSEND), 
              CONS(EXPRESSION, pvm_encoding_option(1),
              CONS(EXPRESSION, entity_to_expression(hpfc_name_to_entity(BUFID)),
                   NIL)));
 
    return lazy ? make_block_statement
        (CONS(STATEMENT, init,
         CONS(STATEMENT, set_logical(hpfc_name_to_entity(LAZY_SEND), false),
              NIL))) :
                  init ;
}

References BUFID, CONS, entity_to_expression(), EXPRESSION, hpfc_make_call_statement(), hpfc_name_to_entity(), init, LAZY_SEND, make_block_statement(), NIL, pvm_encoding_option(), PVM_INITSEND, set_logical, and STATEMENT.

Referenced by gen().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_install()

bool hpfc_install

(

const string

name

)

bool hpfc_install(string name)

what: install generated files in a directory. done for wpips. how: all in the hpfc_install shell script. input: program name. output: none. side effects:

• creates an hpfc directory in the database
• copies the files in this directory... bugs or features:

Parameters

name

ame

Definition at line 838 of file hpfc.c.

{
  string dir, wks;
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering program %s\n", name);
 
  dir = db_get_current_workspace_directory();
  wks = db_get_current_workspace_name();
 
  safe_system(concatenate("hpfc_install -iob ", dir, " -n ", wks, NULL));
 
  DB_PUT_FILE_RESOURCE(DBR_HPFC_INSTALLATION, name, NO_FILE);
 
  debug_off();
  return true;
}

References concatenate(), db_get_current_workspace_directory(), db_get_current_workspace_name(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, NO_FILE, pips_debug, and safe_system().

Here is the call graph for this function:

hpfc_integer_constant_expression_p()

bool hpfc_integer_constant_expression_p	(	expression	e,
		int *	pi
	)

just to avoid a gcc warning

Parameters

pi

i

Definition at line 514 of file align-checker.c.

{
    normalized n = expression_normalized(e);
 
    if (normalized_undefined_p(n)) 
    {
        n = NORMALIZE_EXPRESSION(e);
    }
 
    switch (normalized_tag(n))
    {
    case is_normalized_complex:
        return(false);
        break;
    case is_normalized_linear:
    {
        Pvecteur  v = (Pvecteur) normalized_linear(n),
            vp = vect_del_var(v, TCST);
        int s = vect_size(vp);
        bool result = (s==0);
 
        vect_rm(vp);
 
        if (result)
        {
            Value vi = vect_coeff(TCST, v);
            *pi = VALUE_TO_INT(vi);
        }
        
        return(result);
        break;
    }
    default:
        pips_internal_error("unexpected normalized tag");
        break;
    }
    
    return(false); /* just to avoid a gcc warning */
}

References expression_normalized, is_normalized_complex, is_normalized_linear, NORMALIZE_EXPRESSION, normalized_linear, normalized_tag, normalized_undefined_p, pips_internal_error, TCST, VALUE_TO_INT, vect_coeff(), vect_del_var(), vect_rm(), and vect_size().

Referenced by align_check(), compute_entity_to_declaration_constraints(), empty_range_p(), fprint_range(), lrange_larger_p(), safe_static_domain_bound(), and sprint_range().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_intrinsic_like_function()

bool hpfc_intrinsic_like_function

(

entity

e

)

Definition at line 828 of file run-time.c.

{
    RunTimeSupportDescriptor *entry = find_entry_by_name(entity_local_name(e));
 
    return entry ? entry->what==is_ifn : false;
}

References entity_local_name(), find_entry_by_name(), is_ifn, and RunTimeSupportDescriptor::what.

Here is the call graph for this function:

hpfc_io_like_function()

bool hpfc_io_like_function

(

entity

e

)

Definition at line 836 of file run-time.c.

{
    RunTimeSupportDescriptor *entry = find_entry_by_name(entity_local_name(e));
 
    return entry ? entry->what==is_iof : false;
}

References entity_local_name(), find_entry_by_name(), is_iof, and RunTimeSupportDescriptor::what.

Referenced by only_io_call().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_io_util_error_handler()

void hpfc_io_util_error_handler

(

void

)

??? neglect expression side effects...

Definition at line 82 of file io-util.c.

{
    error_reset_current_statement_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

hpfc_lazy_buffer_packing()

statement hpfc_lazy_buffer_packing	(	entity	,
		entity	,
		entity	,
		entity	,
		entity(*)(void)	,
		bool	,
		bool
	)

hpfc_lazy_guard()

statement hpfc_lazy_guard	(	bool	snd,
		statement	then
	)

returns if (LAZY_{SEND,RECV}) then

Parameters

snd	nd
then	hen

Definition at line 176 of file generate-util.c.

{
    entity decision = hpfc_name_to_entity(snd ? LAZY_SEND : LAZY_RECV);
    return test_to_statement
     (make_test(entity_to_expression(decision), then, make_empty_statement()));
}

References entity_to_expression(), hpfc_name_to_entity(), LAZY_RECV, LAZY_SEND, make_empty_statement, make_test(), and test_to_statement.

Referenced by broadcast(), and hpfc_lazy_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_lazy_packing()

statement hpfc_lazy_packing	(	entity	,
		entity	,
		entity(*)(void)	,
		bool	,
		bool
	)

hpfc_main_entity()

entity hpfc_main_entity

(

entity

e

)

returns the entity to which e is attached, that is first a common, then a function...

Definition at line 462 of file run-time.c.

{
    storage s = entity_storage(e);
    bool in_common = entity_in_common_p(e),
         in_ram = storage_ram_p(s);
    ram r = (in_ram ? storage_ram(s) : ram_undefined);
 
    pips_assert("not in rom", !storage_rom_p(s));
 
    return(in_ram ?
           (in_common ? ram_section(r) : ram_function(r)):
           (storage_formal_p(s) ? formal_function(storage_formal(s)) :
            (storage_return_p(s) ? storage_return(s) : entity_undefined)));
}

References entity_in_common_p(), entity_storage, entity_undefined, formal_function, pips_assert, ram_function, ram_section, ram_undefined, storage_formal, storage_formal_p, storage_ram, storage_ram_p, storage_return, storage_return_p, and storage_rom_p.

Referenced by hpfc_main_entity_name(), and list_of_distributed_arrays_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_main_entity_name()

const char* hpfc_main_entity_name

(

entity

e

)

returns the name of the entity e belongs too (common, function...)

Definition at line 479 of file run-time.c.

{
    return(module_local_name(hpfc_main_entity(e)));
}

References hpfc_main_entity(), and module_local_name().

Referenced by bound_parameter_name().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_make()

bool hpfc_make

(

const string

name

)

bool hpfc_make(string name)

what: compile the generated and installed code. for wpips. how: system call to $HPFC_MAKE input: the workspace name (which is not used) output: none. side effects: may stop if can't execute bugs or features:

Parameters

name

ame

Definition at line 864 of file hpfc.c.

{
  string dir = db_get_current_workspace_directory();
 
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering program %s\n", name);
 
  safe_system(concatenate("cd ", dir, "/hpfc ; "
                          "${HPFC_MAKE:-gmake} make &", NULL));
 
  debug_off();
  return true;
}

References concatenate(), db_get_current_workspace_directory(), debug_off, debug_on, pips_debug, and safe_system().

Here is the call graph for this function:

hpfc_make_call_statement()

statement hpfc_make_call_statement	(	entity	e,
		list	l
	)

statement hpfc_make_call_statement(e, l) generate a call statement to function e, with expression list l as an argument.

Definition at line 318 of file run-time.c.

{
    pips_assert("defined", !entity_undefined_p(e));
    return instruction_to_statement(make_instruction(is_instruction_call,
                                               make_call(e, l)));
}

References entity_undefined_p, instruction_to_statement(), is_instruction_call, make_call(), make_instruction(), and pips_assert.

Referenced by add_pvm_init_and_end(), generate_subarray_shift(), hpfc_hcast(), hpfc_hmessage(), hpfc_initsend(), hpfc_message(), hpfc_nrecv(), hpfc_nsend(), hpfc_packing_of_current__buffer(), io_efficient_compile(), st_call_send_or_receive(), st_compute_current_computer(), st_compute_current_owners(), st_compute_neighbour(), st_generate_packing(), and statement_compute_bounds().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_message()

statement hpfc_message	(	expression	tid,
		expression	channel,
		bool	send
	)

Parameters

tid	id
channel	hannel
send	end

Definition at line 152 of file generate-util.c.

{
    expression third;
    entity pvmf;
 
    third = entity_to_expression(hpfc_name_to_entity(send ? INFO : BUFID));
    pvmf = hpfc_name_to_entity(send ? PVM_SEND : PVM_RECV);
 
    return make_block_statement
           (CONS(STATEMENT, hpfc_make_call_statement(pvmf,
                                   CONS(EXPRESSION, tid,
                                   CONS(EXPRESSION, channel,
                                   CONS(EXPRESSION, third,
                                        NIL)))),
            CONS(STATEMENT, hpfc_add_2(copy_expression(channel)),
                 NIL)));
}

References BUFID, CONS, copy_expression(), entity_to_expression(), EXPRESSION, hpfc_add_2(), hpfc_make_call_statement(), hpfc_name_to_entity(), INFO, make_block_statement(), NIL, PVM_RECV, PVM_SEND, and STATEMENT.

Referenced by hpfc_generate_message(), and hpfc_lazy_message().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_module_suffix()

string hpfc_module_suffix

(

entity

module

)

else

to avoid a gcc warning

Parameters

module

odule

Definition at line 126 of file host_node_entities.c.

{
    if (module==node_module) return(NODE_NAME);
    if (module==host_module) return(HOST_NAME);
    /* else
     */
    pips_internal_error("unexpected module");
    return string_undefined; /* to avoid a gcc warning */
}

References host_module, HOST_NAME, module, node_module, NODE_NAME, pips_internal_error, and string_undefined.

hpfc_name_to_entity()

entity hpfc_name_to_entity

(

const char *

name

)

just to avoid a gcc warning

Parameters

name

ame

Definition at line 817 of file run-time.c.

{
    RunTimeSupportDescriptor *entry = find_entry_by_name(name);
 
    if (entry) return entry->object;
 
    pips_internal_error("%s not found", name);
 
    return entity_undefined; /* just to avoid a gcc warning */
}

References entity_undefined, find_entry_by_name(), RunTimeSupportDescriptor::object, and pips_internal_error.

Referenced by add_pvm_init_and_end(), broadcast(), buffer_full_condition(), define_node_processor_id(), elements_loop(), expr_compute_local_index(), gen(), generate_io_statements_for_shared_arrays(), generate_remapping_code(), generate_remapping_guard(), GENERATION(), hpfc_broadcast_if_necessary(), hpfc_buffer_entity(), hpfc_buffer_initialization(), hpfc_buffer_packing(), hpfc_compute_lid(), hpfc_generate_message(), hpfc_hcast(), hpfc_hmessage(), hpfc_initsend(), hpfc_lazy_buffer_packing(), hpfc_lazy_guard(), hpfc_lazy_message(), hpfc_lazy_packing(), hpfc_message(), hpfc_nrecv(), hpfc_nsend(), hpfc_translate_call_with_distributed_args(), if_different_pe_and_not_twin(), io_efficient_compile(), live_mapping_expression(), make_mypos_expression(), make_rectangular_area(), mylid_ne_lid(), processor_loop(), set_array_status_to_target(), set_resources_for_module(), st_compute_current_computer(), st_compute_current_owners(), st_compute_neighbour(), and statement_compute_bounds().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_new_variable()

entity hpfc_new_variable	(	entity	module,
		basic	b
	)

Parameters

module

odule

Definition at line 632 of file compile.c.

{
    entity new_ent =  make_new_scalar_variable(module, copy_basic(b));
    AddEntityToCurrentModule(new_ent);
    return new_ent;
}

References AddEntityToCurrentModule(), copy_basic(), make_new_scalar_variable(), and module.

Referenced by extract_lattice(), generate_copy_loop_nest(), loop_flt(), and NormalizeCodeForHpfc().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_order_variables()

list hpfc_order_variables	(	list	le,
		bool	number_first
	)

list hpfc_order_variables(list)

the input list of entities is ordered so that: PSI_i's, GAMMA_i's, DELTA_i's, IOTA_i's, ALPHA_i's, LALPHA_i's...

reverse!

Parameters

le	e
number_first	umber_first

Definition at line 629 of file io-compile.c.

{
    list result = NIL;
 
    result =
        gen_nconc(result,
                  hpfc_order_specific_variables(le, get_ith_processor_dummy));
    
    if (number_first)
    {
        int i;
        list l = NIL, lr = NIL;
 
        for (i=7; i>0; i--)
            l = CONS(ENTITY, get_ith_array_dummy(i),
                CONS(ENTITY, get_ith_shift_dummy(i),
                CONS(ENTITY, get_ith_block_dummy(i),
                CONS(ENTITY, get_ith_cycle_dummy(i),
                       l))));
 
        MAP(ENTITY, e,
        {
            if (gen_in_list_p(e, le)) lr = CONS(ENTITY, e, lr); /* reverse! */
        },
            l);
 
        gen_free_list(l);
        result = gen_nconc(result, lr);
    }
    else
    {
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_cycle_dummy));
        
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_block_dummy));
        
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_shift_dummy));
        
        result = 
            gen_nconc(result,
                      hpfc_order_specific_variables(le, get_ith_array_dummy));
    }
 
    result = 
        gen_nconc(result,
                  hpfc_order_specific_variables(le, get_ith_local_dummy));
 
    pips_assert("same length", gen_length(result)==gen_length(le));
    
    return(result);
}

References CONS, ENTITY, gen_free_list(), gen_in_list_p(), gen_length(), gen_nconc(), get_ith_array_dummy(), get_ith_block_dummy(), get_ith_cycle_dummy(), get_ith_local_dummy(), get_ith_processor_dummy(), get_ith_shift_dummy(), hpfc_order_specific_variables(), MAP, NIL, and pips_assert.

Referenced by put_variables_in_ordered_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_packing_of_current__buffer()

statement hpfc_packing_of_current__buffer	(	entity	array,
		bool	pack
	)

CALL (pvmtype) HPFC {,UN}PACK.

Parameters

array	rray
pack	ack

Definition at line 395 of file generate-util.c.

{
    return hpfc_make_call_statement
        (hpfc_buffer_entity(array, pack? BUFPCK: BUFUPK), NIL);
}

References array, BUFPCK, BUFUPK, hpfc_buffer_entity(), hpfc_make_call_statement(), and NIL.

Referenced by hpfc_broadcast_if_necessary(), hpfc_hcast(), hpfc_hmessage(), hpfc_nrecv(), and hpfc_nsend().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_print_code()

void hpfc_print_code	(	FILE *	file,
		entity	module,
		statement	stat
	)

Parameters

file	ile
module	odule
stat	tat

Definition at line 393 of file compile.c.

{
    text t;
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
 
    set_prettyprinter_head_hook(hpfc_head_hook);
    set_prettyprinter_common_hook(hpfc_common_hook);
 
    t = text_module(module, stat);
    print_text(file, t);
    free_text(t);
    
    reset_prettyprinter_common_hook();
    reset_prettyprinter_head_hook();
 
    debug_off();
}

References debug_off, debug_on, free_text(), hpfc_common_hook(), hpfc_head_hook(), module, print_text(), reset_prettyprinter_common_hook(), reset_prettyprinter_head_hook(), set_prettyprinter_common_hook(), set_prettyprinter_head_hook(), and text_module().

Referenced by put_generated_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_print_common()

void hpfc_print_common	(	FILE *	file,
		entity	module,
		entity	common
	)

Parameters

file	ile
module	odule
common	ommon

Definition at line 154 of file debug-util.c.

{
    text t;
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
 
    t = text_common_declaration(common, module);
    print_text(file, t);
    free_text(t);
    
    debug_off();
}

References debug_off, debug_on, free_text(), module, print_text(), and text_common_declaration().

Referenced by put_generated_resources_for_common().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_print_file()

void hpfc_print_file

(

string

file_name

)

Parameters

file_name

ile_name

Definition at line 169 of file debug-util.c.

{
    string dir_name = db_get_current_workspace_directory();
 
    safe_system(concatenate("cat ", dir_name, "/", file_name, " >&2", NULL));
}

References concatenate(), db_get_current_workspace_directory(), file_name, and safe_system().

Referenced by put_generated_resources_for_common(), put_generated_resources_for_module(), and put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_run()

bool hpfc_run

(

const string

name

)

bool hpfc_run(string name)

what: run the program. how: system call sut $HPFC_MAKE... input: none. output: none. side effects:

• forks a process.
• may stop if cannot execute. bugs or features:

Parameters

name

ame

Definition at line 889 of file hpfc.c.

{
  string dir = db_get_current_workspace_directory();
 
  debug_on("HPFC_DEBUG_LEVEL");
  pips_debug(1, "considering program %s\n", name);
 
  safe_system(concatenate("cd ", dir, "/hpfc ; "
                          "${HPFC_MAKE:-gmake} run &", NULL));
 
  debug_off();
  return true;
}

References concatenate(), db_get_current_workspace_directory(), debug_off, debug_on, pips_debug, and safe_system().

Here is the call graph for this function:

hpfc_simplify_condition()

void hpfc_simplify_condition	(	Psysteme *	psc,
		statement	stat,
		tag	move
	)

void hpfc_simplify_condition(psc, stat, move)

remove conditions that are not usefull from *psc, i.e. that are redundent with pre/post conditions depending on when the movement is done

Parameters

psc	sc
stat	tat
move	ove

Definition at line 724 of file io-compile.c.

{
    Psysteme
        pstrue = statement_context(stat, move),
        cleared = extract_nredund_subsystem(*psc, pstrue);
 
    *psc = (sc_rm(*psc), cleared);
}

References extract_nredund_subsystem(), sc_rm(), and statement_context().

Referenced by generate_io_collect_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_special_cases_error_handler()

void hpfc_special_cases_error_handler

(

void

)

Definition at line 705 of file special_cases.c.

{
    error_reset_current_stmt_stack();
    error_reset_current_call_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

hpfc_special_fake()

bool hpfc_special_fake

(

entity

f

)

Definition at line 91 of file hpfc.c.

{ return gen_in_list_p(f, the_fakes_object);}

References f(), gen_in_list_p(), and the_fakes_object.

Referenced by hpfc_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_special_io()

bool hpfc_special_io

(

entity

f

)

Definition at line 77 of file hpfc.c.

{ return gen_in_list_p(f, the_ios_object);}

References f(), and gen_in_list_p().

Referenced by hpfc_compile(), and only_io_call().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_static_directives()

bool hpfc_static_directives

(

const

string

)

Parameters

string

ame

Definition at line 676 of file hpfc.c.

{
  return hpfc_directives_handler(name, false);
}

References hpfc_directives_handler().

Here is the call graph for this function:

hpfc_translate_call_with_distributed_args()

void hpfc_translate_call_with_distributed_args	(	statement	s,
		call	c
	)

??? only simple calls are handled.

imbrication may cause problems. ??? should recurse thru all the calls at a call instruction... the call. (not necessarily an instruction)

of remapping

of expression

the substitution in the call will be performed at the propagation phase of dynamic arrays, later on.

add the renaming in the list. ??? should be added only once! what about call(A,A)...

should always be the case

of statement

Do not forget to move forbidden information associated with block:

Parameters

c	the statement the call belongs to

Definition at line 687 of file dynamic.c.

{
    list /* of remapping */ lr = NIL,
         /* of expression */ args;
    int len, i;
    entity f;
 
    f = call_function(c);
    args = call_arguments(c);
    len = gen_length(args);
 
    pips_debug(1, "function %s\n", entity_name(f));
 
    for (i=1; i<=len; i++, POP(args))
    {
        entity arg = find_ith_parameter(f, i);
        pips_debug(7, "considering argument %d\n", i);
 
        if (array_distributed_p(arg))
        {
            align al;
            entity passed, copy;
            expression e = EXPRESSION(CAR(args));
 
            passed = expression_to_entity(e);
 
            pips_debug(8, "passed:%s, arg:%s\n", 
                       entity_name(passed), entity_name(arg));
            pips_assert("distributed and conformant",
                        array_distributed_p(passed) &&
                        conformant_entities_p(passed, arg));
 
            set_entity_as_dynamic(passed);
            add_a_dynamic(passed);
 
            al = copy_align(load_hpf_alignment(arg));
            copy = array_synonym_aligned_as(passed, al);
 
            pips_debug(3, "%s (arg %d) %s -> %s\n", entity_name(arg), i, 
                       entity_name(passed), entity_name(copy));
 
            /* the substitution in the call will be performed at the 
             * propagation phase of dynamic arrays, later on.
             */
            /* add the renaming in the list.
             * ??? should be added only once! what about call(A,A)...
             */
            lr = add_once_to_renaming_list(lr, passed, copy);
        }
    }
 
    if (lr) /* should always be the case */
    {
        list /* of statement */ lpre = NIL, lpos = NIL;
        entity rename = hpfc_name_to_entity(HPF_PREFIX RENAME_SUFFIX);
        
        lpre = CONS(STATEMENT, 
                    instruction_to_statement(statement_instruction(s)), 
                    NIL);
 
        MAP(RENAMING, r,
        {
            entity passed = renaming_old(r);
            entity copied = renaming_new(r);
 
            lpre = CONS(STATEMENT, call_to_statement(make_call(rename,
                        CONS(EXPRESSION, entity_to_expression(passed),
                        CONS(EXPRESSION, entity_to_expression(copied), NIL)))),
                        lpre);
 
            lpos = CONS(STATEMENT, call_to_statement(make_call(rename,
                        CONS(EXPRESSION, entity_to_expression(copied),
                        CONS(EXPRESSION, entity_to_expression(passed), NIL)))),
                        lpos);
        },
            lr);
 
        statement_instruction(s) = 
            make_instruction_block(gen_nconc(lpre, lpos));
        /* Do not forget to move forbidden information associated with
           block: */
        fix_sequence_statement_attributes(s);   
        
        DEBUG_STAT(3, "out", s);
    }
}

References add_a_dynamic(), add_once_to_renaming_list(), array_distributed_p(), array_synonym_aligned_as(), call_arguments, call_function, call_to_statement, CAR, conformant_entities_p(), CONS, copy_align(), DEBUG_STAT, entity_name, entity_to_expression(), EXPRESSION, expression_to_entity(), f(), find_ith_parameter(), fix_sequence_statement_attributes(), gen_length(), gen_nconc(), HPF_PREFIX, hpfc_name_to_entity(), instruction_to_statement(), load_hpf_alignment(), make_call(), make_instruction_block(), MAP, NIL, pips_assert, pips_debug, POP, RENAME_SUFFIX, RENAMING, renaming_new, renaming_old, set_entity_as_dynamic(), STATEMENT, and statement_instruction.

Referenced by prescription_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_unstutter_dummies()

Psysteme hpfc_unstutter_dummies

(

entity

array

)

Parameters

array

rray

Definition at line 767 of file build-system.c.

{
    int ndim = variable_entity_dimension(array);
 
    return generate_system_for_equal_variables
           (ndim, get_ith_region_dummy, get_ith_array_dummy);
}

References array, generate_system_for_equal_variables(), get_ith_array_dummy(), get_ith_region_dummy(), and variable_entity_dimension().

Referenced by generate_distributed_io_system(), and generate_shared_io_system().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_util_error_handler()

void hpfc_util_error_handler

(

void

)

removes IF (.TRUE.) THEN and DO X=n, n

Definition at line 785 of file hpfc-util.c.

{
    error_reset_current_stmt_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

HpfcExpressionToInt()

int HpfcExpressionToInt

(

expression

e

)

HpfcExpressionToInt(e)

uses the normalized value if possible.

just to avoid a gcc warning

Definition at line 569 of file hpfc-util.c.

{
    normalized n = expression_normalized(e);
    intptr_t val = 0;
 
    ifdebug(8) print_expression(e);
 
    if ((n!=normalized_undefined) && (normalized_linear_p(n)))
    {
        Pvecteur v = normalized_linear(n);
        int s = vect_size(v), val;
        Value vval = vect_coeff(TCST, v);
 
        val = VALUE_TO_INT(vval);
        if (s==0) return 0;
        if ((s==1) && (val!=0)) return val;
    }
    
    /*
    if (expression_integer_constant_p(e))
        return ExpressionToInt(e);
    */
    if(expression_integer_value(e, &val))
        return val;
    else
        pips_internal_error("can't return anything, sorry");
 
    return -1; /* just to avoid a gcc warning */
}

References expression_integer_value(), expression_normalized, ifdebug, intptr_t, normalized_linear, normalized_linear_p, normalized_undefined, pips_internal_error, print_expression(), TCST, VALUE_TO_INT, vect_coeff(), and vect_size().

Referenced by align_check(), array_access_to_array_ranges(), array_ranges_to_template_ranges(), complementary_range(), compute_receive_content(), compute_receive_domain(), ComputeNewSizeOfIthDimension(), create_init_common_param_for_arrays(), create_init_common_param_for_processors(), create_init_common_param_for_templates(), create_parameters_h(), DistributionParameterOfArrayDim(), expr_compute_local_index(), generate_one_message(), get_alignment(), get_distribution(), get_ith_dim_new_declaration(), global_array_cell_to_local_array_cell(), handle_set_directive(), hpfc_compute_align_constraints(), hpfc_compute_distribute_constraints(), hpfc_compute_unicity_constraints(), loop_filter(), make_guard_expression(), NormalizeOneTemplateDistribution(), overlap_redefine_expression(), processor_number(), same_alignment_p(), shape_one_message(), simple_indices_p(), template_cell_local_mapping(), and template_ranges_to_processors_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfcompile()

void hpfcompile

(

const char *

module_name

)

Compiler call, obsole.

left here for allowing linking

Parameters

module_name

odule_name

Definition at line 601 of file compile.c.

{
    debug_on("HPFC_DEBUG_LEVEL");
    pips_debug(1, "module: %s\n", module_name);
    pips_internal_error("obsolete");
    debug_off();
}

References debug_off, debug_on, module_name(), pips_debug, and pips_internal_error.

Here is the call graph for this function:

IndicesOfRef()

list IndicesOfRef

(

syntax

syn

)

??? could check that the given call is a constant.

Parameters

syn

yn

Definition at line 156 of file compiler-util.c.

{
    list l = NIL;
 
    pips_assert("reference", syntax_reference_p(syn));
 
    MAP(EXPRESSION, e,
     {
         syntax s = expression_syntax(e);
 
         switch (syntax_tag(s))
         {
         case is_syntax_reference:
             l = CONS(SYNTAX, s, l);
             break;
         case is_syntax_range:
             pips_internal_error("don't konw what to do with a range");
             break;
         case is_syntax_call:
             /*     ??? could check that the given call is a constant.
              */
             break;
         default:
             pips_internal_error("unexpected syntax tag");
         }       
     },
         reference_indices(syntax_reference(syn)));
 
    return(l);   
}

References CONS, EXPRESSION, expression_syntax, is_syntax_call, is_syntax_range, is_syntax_reference, MAP, NIL, pips_assert, pips_internal_error, reference_indices, SYNTAX, syntax_reference, syntax_reference_p, and syntax_tag.

Referenced by lIndicesOfRef().

Here is the caller graph for this function:

indirections_inside_statement_p()

bool indirections_inside_statement_p

(

statement

)

init_data_status()

void init_data_status

(

void

)

Definition at line 300 of file declarations.c.

{
    init_new_declaration();
    init_hpf_alignment();
    init_hpf_distribution();
    reset_hpf_object_lists();
}

References init_hpf_alignment(), init_hpf_distribution(), and reset_hpf_object_lists().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

init_dynamic_hpf()

void init_dynamic_hpf

(

void

)

Referenced by init_dynamic_status().

Here is the caller graph for this function:

init_dynamic_locals()

void init_dynamic_locals

(

void

)

DYNAMIC LOCAL DATA.

these static functions are used to store the remapping graph while it is built, or when optimizations are performed on it.

• alive_synonym: used when building the remapping graph. synonym of a primary entity that has reached a given remapping statement. Used for both arrays and templates.
• used_dynamics: from a remapping statement, the remapped arrays that are actually referenced in their new shape.
• modified_dynamics: from a remapping statement, the remapped arrays that may be modified in their new shape.
• remapping_graph: the remapping graph, based on the control domain. the control_statement is the remapping statement in the code. predecessors and successors are the possible remapping statements for the arrays remapped at that vertex.
• reaching_mappings: the mappings that may reached a vertex.
• leaving_mappings: the mappings that may leave the vertex. (simplification assumption: only one per array)
• remapped: the (primary) arrays remapped at the vertex.

Definition at line 806 of file dynamic.c.

{
    init_alive_synonym();
    init_used_dynamics();
    init_modified_dynamics();
    init_reaching_mappings();
    init_leaving_mappings();
    init_remapped();
    init_remapping_graph();
}

Referenced by handle_hpf_directives().

Here is the caller graph for this function:

init_dynamic_status()

void init_dynamic_status

(

void

)

DYNAMIC STATUS management.

Definition at line 81 of file dynamic.c.

{
    init_dynamic_hpf();
    init_primary_entity();
    init_renamings();
    init_maybeuseful_mappings();
    init_similar_mapping();
}

References init_dynamic_hpf(), init_maybeuseful_mappings(), init_primary_entity(), init_renamings(), and init_similar_mapping().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

init_entity_status()

void init_entity_status

(

void

)

Definition at line 85 of file host_node_entities.c.

{
    init_new_host();
    init_old_host();
    init_new_node();
    init_old_node();
}

References init_new_host(), init_new_node(), init_old_host(), and init_old_node().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

init_host_and_node_entities()

void init_host_and_node_entities

(

void

)

both host and node modules are initialized with the same declarations than the compiled module, but the distributed arrays declarations...

which are not declared in the case of the host_module, and the declarations of which are modified in the node_module (call to NewDeclarationsOfDistributedArrays)...

First, the commons are updated

COMMONS

Then, the other entities

parameters are selected. I think they may be either functional of variable (if declared...) FC 15/09/93

VARIABLES

PARAMETERS

Definition at line 246 of file compile.c.

{
    entity current_module = get_current_module_entity();
 
    ifdebug(3)
    {
        text t;
        debug_on("PRETTYPRINT_DEBUG_LEVEL");
        pips_debug(3, "old declarations:\n");
        t = text_declaration(current_module);
        print_text(stderr, t);
        free_text(t);
        debug_off();
    }
 
    host_module = load_new_host(current_module);
    node_module = load_new_node(current_module);
 
    /*  First, the commons are updated
     */
    MAP(ENTITY, e,
     {
         type t = entity_type(e);
 
         if (type_area_p(t) && !entity_special_area_p(e))
         {
             debug(3, "init_host_and_node_entities",    /* COMMONS */
                   "considering common %s\n", entity_name(e));
 
             AddCommonToHostAndNodeModules(e); 
             add_a_common(e);
         }
     },
         entity_declarations(current_module)); 
 
    /*   Then, the other entities
     */
    MAP(ENTITY, e,
     {
         type t = entity_type(e);
 
         /* parameters are selected. I think they may be either
          * functional of variable (if declared...) FC 15/09/93
          */
 
         if ((type_variable_p(t)) ||                    /* VARIABLES */
             ((storage_rom_p(entity_storage(e))) &&
              (value_symbolic_p(entity_initial(e)))))
             AddEntityToHostAndNodeModules(e);
         else
         if (type_functional_p(t))                      /* PARAMETERS */
         {
             AddEntityToDeclarations(e, host_module);   
             AddEntityToDeclarations(e, node_module);
         }
     },
         entity_declarations(current_module));
    
    NewDeclarationsOfDistributedArrays();    
 
    drop_distributed_arguments(host_module);
    add_bound_arguments(node_module);
 
    ifdebug(3)
    {
        text t;
        debug_on("PRETTYPRINT_DEBUG_LEVEL");
        pips_debug(3,"new declarations - node_module:\n");
        (void) entity_consistent_p(node_module);
        t = text_declaration(node_module);
        print_text(stderr, t);
        free_text(t);
 
        pips_debug(3, "new declarations - host_module:\n");
        (void) entity_consistent_p(host_module);
        t = text_declaration(host_module);
        print_text(stderr, t);
        free_text(t);
        debug_off();
    }
}

References add_a_common(), add_bound_arguments(), AddCommonToHostAndNodeModules(), AddEntityToDeclarations(), AddEntityToHostAndNodeModules(), current_module, debug(), debug_off, debug_on, drop_distributed_arguments(), ENTITY, entity_consistent_p(), entity_declarations, entity_initial, entity_name, entity_special_area_p(), entity_storage, entity_type, free_text(), get_current_module_entity(), host_module, ifdebug, load_new_host(), load_new_node(), MAP, NewDeclarationsOfDistributedArrays(), node_module, pips_debug, print_text(), storage_rom_p, text_declaration(), type_area_p, type_functional_p, type_variable_p, and value_symbolic_p.

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

init_hpf_alignment()

void init_hpf_alignment

(

void

)

Referenced by init_data_status().

Here is the caller graph for this function:

init_hpf_distribution()

void init_hpf_distribution

(

void

)

Referenced by init_data_status().

Here is the caller graph for this function:

init_hpf_number()

void init_hpf_number

(

void

)

Referenced by init_hpf_number_status().

Here is the caller graph for this function:

init_hpf_number_status()

void init_hpf_number_status

(

void

)

STANDARS STATIC MANAGEMENT.

functions: {init,get,set,reset,close}_hpf_number_status

Definition at line 128 of file declarations.c.

{
    init_hpf_number();
    init_currents();
}

References init_currents(), and init_hpf_number().

Referenced by init_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

init_hpf_reductions()

void init_hpf_reductions

(

void

)

Referenced by init_hpfc_status().

Here is the caller graph for this function:

init_maybeuseful_mappings()

void init_maybeuseful_mappings

(

void

)

Referenced by init_dynamic_status().

Here is the caller graph for this function:

init_new_host()

void init_new_host

(

void

)

Referenced by init_entity_status().

Here is the caller graph for this function:

init_new_node()

void init_new_node

(

void

)

Referenced by init_entity_status().

Here is the caller graph for this function:

init_old_host()

void init_old_host

(

void

)

Referenced by init_entity_status().

Here is the caller graph for this function:

init_old_node()

void init_old_node

(

void

)

Referenced by init_entity_status().

Here is the caller graph for this function:

init_overlap_status()

void init_overlap_status

(

void

)

Referenced by init_hpfc_status().

Here is the caller graph for this function:

init_primary_entity()

void init_primary_entity

(

void

)

Referenced by init_dynamic_status().

Here is the caller graph for this function:

init_renamings()

void init_renamings

(

void

)

Referenced by init_dynamic_status().

Here is the caller graph for this function:

init_similar_mapping()

void init_similar_mapping

(

void

)

Referenced by init_dynamic_status().

Here is the caller graph for this function:

init_the_dynamics()

void init_the_dynamics

(

void

)

Referenced by handle_hpf_directives().

Here is the caller graph for this function:

io_efficient_compile()

void io_efficient_compile	(	statement	stat,
		statement *	hp,
		statement *	np
	)

compile an io statement

returned Node code

of effect

not implemented

Parameters

stat	tat
hp	statement to compile
np	returned Host code

Definition at line 911 of file io-compile.c.

{
  list
    /* of effect */ entities = load_rw_effects_list(stat),
    lh_collect = NIL, lh_io = NIL, lh_update = NIL,
    ln_collect = NIL, ln_io = NIL, ln_update = NIL;
  statement sh, sn;
 
  debug_on("HPFC_IO_DEBUG_LEVEL");
  pips_debug(1, "compiling!\n");
  pips_debug(2, "statement %" _intFMT " (%p), %zd arrays\n",
             statement_number(stat), stat, gen_length(entities));
 
  // quicker for continue and so...
  if (empty_code_p(stat))
  {
    pips_debug(3, "empty statement\n");
    *hp = copy_statement(stat);
    *np = copy_statement(stat);
    debug_off();
    return;
  }
 
  // for each effect e on that statement
  FOREACH(effect, e, entities)
  {
    entity array = reference_variable(effect_any_reference(e));
    pips_debug(3, "variable %s\n", entity_name(array));
 
    if (io_effect_entity_p(array)) // skip LUNS
      continue;
 
    action act = effect_action(e);
    approximation apr = effect_approximation(e);
 
    pips_assert("avoid replicated array I/O", /* not implemented */
                !(array_distributed_p(array) && replicated_p(array)));
 
    if ((!array_distributed_p(array)) && action_read_p(act))
    {
      pips_debug(7, "skipping array %s movements - none needed\n",
                 entity_name(array));
      continue;
    }
 
    // add array declaration on host if necessary
    if (array_distributed_p(array) && !bound_new_host_p(array))
      add_declaration_to_host_and_link(array);
 
    // collect data if necessary
    if (array_distributed_p(array) &&
        current_entity_is_updated_before_p(stat,array) &&
        (action_read_p(act) ||
         (action_write_p(act) &&
          approximation_may_p(apr) &&
          !get_bool_property("HPFC_IGNORE_MAY_IN_IO"))))
    {
      generate_io_collect_or_update(array, stat, is_movement_collect,
                                    action_tag(act), &sh, &sn);
      lh_collect = CONS(STATEMENT, sh, lh_collect);
      ln_collect = CONS(STATEMENT, sn, ln_collect);
    }
 
    // update data if necessary
    // action = write and data may be used later (out regions)
    if (action_write_p(act) && current_entity_is_used_later_p(stat,array))
    {
      generate_io_collect_or_update(array, stat, is_movement_update,
                                    action_tag(act), &sh, &sn);
      lh_update = CONS(STATEMENT, sh, lh_update);
      ln_update = CONS(STATEMENT, sn, ln_update);
    }
  }
 
  lh_io =  CONS(STATEMENT, copy_statement(stat), NIL);
 
  if (get_bool_property("HPFC_SYNCHRONIZE_IO"))
  {
    // could do it only for write statements
    entity synchro = hpfc_name_to_entity(SYNCHRO);
 
    lh_io = CONS(STATEMENT, hpfc_make_call_statement(synchro, NIL), lh_io);
    ln_io = CONS(STATEMENT, hpfc_make_call_statement(synchro, NIL), ln_io);
  }
 
  *hp = make_block_statement(gen_nconc(lh_collect,
                             gen_nconc(lh_io,
                                       lh_update)));
  *np = make_block_statement(gen_nconc(ln_collect,
                             gen_nconc(ln_io,
                                       ln_update)));
 
  DEBUG_STAT(9, "Host", *hp);
  DEBUG_STAT(9, "Node", *np);
 
  debug_off();
}

References _intFMT, action_read_p, action_tag, action_write_p, add_declaration_to_host_and_link(), approximation_may_p, array, array_distributed_p(), bound_new_host_p(), CONS, copy_statement(), current_entity_is_updated_before_p(), current_entity_is_used_later_p(), debug_off, debug_on, DEBUG_STAT, effect_action, effect_any_reference, effect_approximation, empty_code_p(), entity_name, FOREACH, gen_length(), gen_nconc(), generate_io_collect_or_update(), get_bool_property(), hpfc_make_call_statement(), hpfc_name_to_entity(), io_effect_entity_p(), is_movement_collect, is_movement_update, load_rw_effects_list(), make_block_statement(), NIL, pips_assert, pips_debug, reference_variable, replicated_p(), STATEMENT, statement_number, and SYNCHRO.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

is_in_syntax_list()

bool is_in_syntax_list	(	entity	e,
		list	l
	)

Definition at line 200 of file compiler-util.c.

{
    MAP(SYNTAX, s,
        if (e==reference_variable(syntax_reference(s))) return(true),
        l);
 
    return(false);
}

References MAP, reference_variable, SYNTAX, and syntax_reference.

Referenced by AddOnceToIndicesList(), and FindDefinitionsOf_rewrite().

Here is the caller graph for this function:

ith_dim_distributed_p()

bool ith_dim_distributed_p	(	entity	array,
		int	i,
		int *	pprocdim
	)

whether a dimension is distributed or not.

Parameters

array	rray
pprocdim	procdim

Definition at line 160 of file hpfc-util.c.

{
    align       al = load_hpf_alignment(array);
    list       lal = align_alignment(al);
    alignment  alt = FindAlignmentOfDim(lal, i);
    entity template = align_template(al);
    distribute dis = load_hpf_distribution(template);
    list ld = distribute_distribution(dis);
    distribution d;
 
    if (alignment_undefined_p(alt)) return(false);
    d = FindDistributionOfDim(ld, alignment_templatedim(alt), pprocdim);
    return(!style_none_p(distribution_style(d)));
}

References align_alignment, align_template, alignment_templatedim, alignment_undefined_p, array, distribute_distribution, distribution_style, FindAlignmentOfDim(), FindDistributionOfDim(), load_hpf_alignment(), load_hpf_distribution(), and style_none_p.

Referenced by align_check(), atomize_one_message(), compute_receive_content(), generate_optimized_code_for_loop_nest(), loop_flt(), NewDeclarationOfDistributedArray(), number_of_distributed_dimensions(), shape_one_message(), simple_indices_p(), and subarray_shift_assignment_p().

Here is the call graph for this function:

Here is the caller graph for this function:

ith_dim_overlapable_p()

bool ith_dim_overlapable_p	(	entity	array,
		int	i
	)

Parameters

array

rray

Definition at line 178 of file hpfc-util.c.

{
    align       al = load_hpf_alignment(array);
    list       lal = align_alignment(al);
    alignment  alt = FindAlignmentOfDim(lal, i);
    entity template = align_template(al);
    distribute dis = load_hpf_distribution(template);
    list ld = distribute_distribution(dis);
    distribution d;
    int p;
 
    if (alignment_undefined_p(alt)) return false;
    d = FindDistributionOfDim(ld, alignment_templatedim(alt), &p);
 
    return style_block_p(distribution_style(d));
}

References align_alignment, align_template, alignment_templatedim, alignment_undefined_p, array, distribute_distribution, distribution_style, FindAlignmentOfDim(), FindDistributionOfDim(), load_hpf_alignment(), load_hpf_distribution(), and style_block_p.

Referenced by add_bound_arguments(), caller_list_of_bounds(), create_parameters_h(), and declaration_with_overlaps().

Here is the call graph for this function:

Here is the caller graph for this function:

ith_dim_replicated_p()

bool ith_dim_replicated_p	(	entity	,
		int	,
		list	,
		distribution
	)

kill_statement_number_and_ordering()

void kill_statement_number_and_ordering

(

statement

s

)

Definition at line 232 of file hpfc-util.c.

{
    gen_recurse(s, statement_domain, gen_true, stmt_rwt);
}

References gen_recurse, gen_true(), statement_domain, and stmt_rwt().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

larger_message_in_list()

bool larger_message_in_list	(	message	m,
		list	l
	)

Definition at line 351 of file message-utils.c.

{
    MAP(MESSAGE, mp, if (message_larger_p(mp, m)) return true, l);
    return(false);
}

References MAP, MESSAGE, and message_larger_p().

Referenced by remove_stammering_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

lIndicesOfRef()

list lIndicesOfRef

(

list

lsyn

)

computes the list of indices of the list of ref that are variables...

Parameters

lsyn

syn

Definition at line 147 of file compiler-util.c.

{
    return((ENDP(lsyn))?
           (NULL):
           (AddOnceToIndicesList(IndicesOfRef(SYNTAX(CAR(lsyn))),
                                 lIndicesOfRef(CDR(lsyn)))));
}

References AddOnceToIndicesList(), CAR, CDR, ENDP, IndicesOfRef(), and SYNTAX.

Referenced by hpf_compile_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_distributed_arrays()

list list_of_distributed_arrays

(

void

)

Referenced by alive_arrays(), get_data_status(), list_of_distributed_arrays_for_module(), NewDeclarationsOfDistributedArrays(), print_aligns(), print_distributed_arrays(), and set_similar_mappings_for_updates().

Here is the caller graph for this function:

list_of_distributed_arrays_for_module()

list list_of_distributed_arrays_for_module

(

entity

module

)

returns the list of entities that are 'local' to module

Parameters

module

odule

Definition at line 72 of file declarations.c.

{
    list l = NIL;
 
    MAP(ENTITY, e,
    {
        if (hpfc_main_entity(e)==module) l = CONS(ENTITY, e, l);
    },
        list_of_distributed_arrays());
 
    return(l);
}

References CONS, ENTITY, hpfc_main_entity(), list_of_distributed_arrays(), MAP, module, and NIL.

Referenced by create_init_common_param_for_arrays(), create_parameters_h(), declaration_with_overlaps_for_module(), and root_statement_remapping_inits().

Here is the call graph for this function:

Here is the caller graph for this function:

list_of_processors()

list list_of_processors

(

void

)

Referenced by create_init_common_param_for_processors(), get_data_status(), max_size_of_processors(), and print_processors().

Here is the caller graph for this function:

list_of_templates()

list list_of_templates

(

void

)

Referenced by create_init_common_param_for_templates(), get_data_status(), print_distributes(), and print_templates().

Here is the caller graph for this function:

lNewVariableForModule()

list lNewVariableForModule	(	entity	module,
		list	le
	)

Parameters

module	odule
le	e

Definition at line 263 of file host_node_entities.c.

{
    list result, last;
 
    if (ENDP(le)) return(NIL);
 
    for (result = CONS(ENTITY, 
                       NewVariableForModule(module, ENTITY(CAR(le))),
                       NIL),
         last = result, le = CDR(le);
         !ENDP(le);
         le = CDR(le), last = CDR(last))
        CDR(last) = CONS(ENTITY, NewVariableForModule(module, ENTITY(CAR(le))),
                         NIL);
 
    return(result);
}

References CAR, CDR, CONS, ENDP, ENTITY, module, NewVariableForModule(), and NIL.

Referenced by hpf_compile_sequential_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

load_dynamic_hpf()

entities load_dynamic_hpf

(

entity

)

Referenced by add_dynamic_synonym(), array_synonym_aligned_as(), generate_all_liveness_but(), generate_dynamic_liveness_for_primary(), hpfc_check_for_similarities(), new_synonym(), and template_synonym_distributed_as().

Here is the caller graph for this function:

load_entity_update_common()

entity load_entity_update_common

(

entity

)

Referenced by update_common_rewrite(), and update_loop_rewrite().

Here is the caller graph for this function:

load_hpf_alignment()

align load_hpf_alignment

(

entity

)

Referenced by align_check(), alive_arrays(), array_distribution_similar_p(), array_ranges_to_template_ranges(), array_synonym_aligned_as(), ComputeNewSizeOfIthDimension(), continue_propagation_p(), create_init_common_param_for_arrays(), expr_compute_local_index(), generate_system_for_distributed_variable(), get_alignment(), hpfc_compute_align_constraints(), hpfc_compute_unicity_constraints(), hpfc_translate_call_with_distributed_args(), ith_dim_distributed_p(), ith_dim_overlapable_p(), one_distribute_directive(), print_aligns(), processors_dim_replicated_p(), references_aligned_p(), replicated_p(), and template_dimension_of_array_dimension().

Here is the caller graph for this function:

load_hpf_distribution()

distribute load_hpf_distribution

(

entity

)

Referenced by array_distribution_similar_p(), ComputeNewSizeOfIthDimension(), conformant_templates_p(), create_init_common_param_for_arrays(), create_init_common_param_for_templates(), DistributionParameterOfArrayDim(), expr_compute_local_index(), generate_system_for_distributed_variable(), get_distribution(), hpfc_compute_distribute_constraints(), ith_dim_distributed_p(), ith_dim_overlapable_p(), print_distributes(), processor_number(), processors_dim_replicated_p(), replicated_p(), template_ranges_to_processors_ranges(), and template_synonym_distributed_as().

Here is the caller graph for this function:

load_hpf_number()

intptr_t load_hpf_number

(

entity

)

Referenced by compile_reduction(), create_init_common_param_for_arrays(), create_init_common_param_for_processors(), create_init_common_param_for_templates(), define_node_processor_id(), expr_compute_local_index(), generate_all_liveness_but(), generate_dynamic_liveness_for_primary(), generate_optimized_code_for_loop_nest(), generate_remapping_code(), generate_remapping_guard(), generate_subarray_shift(), hpfc_broadcast_buffers(), hpfc_compute_lid(), if_different_pe_and_not_twin(), make_guard_expression(), remapping_file_name(), set_array_status_to_target(), set_live_status(), st_compute_current_computer(), and st_compute_current_owners().

Here is the caller graph for this function:

load_hpf_reductions()

entities load_hpf_reductions

(

statement

)

Referenced by handle_hpf_reduction(), and handle_reduction_directive().

Here is the caller graph for this function:

load_maybeuseful_mappings()

entities load_maybeuseful_mappings

(

statement

)

Referenced by generate_dynamic_liveness_management(), and propagate_maybeuseful_mappings().

Here is the caller graph for this function:

load_new_host()

entity load_new_host

(

entity

)

Referenced by add_declaration_to_host_and_link(), AddEntityToHostAndNodeModules(), debug_host_node_variables(), generate_read_of_ref_for_all(), generate_update_distributed_value_from_host(), generate_update_private_value_from_host(), init_host_and_node_entities(), NewVariableForModule(), put_generated_resources_for_common(), and update_object_for_module().

Here is the caller graph for this function:

load_new_node()

entity load_new_node

(

entity

)

Referenced by AddEntityToHostAndNodeModules(), caller_list_of_bounds(), complementary_range(), compute_receive_content(), create_parameters_h(), debug_host_node_variables(), declaration_with_overlaps(), generate_c1_alpha(), generate_full_copy(), generate_get_value_locally(), generate_one_message(), generate_parallel_body(), generate_read_of_ref_for_all(), generate_read_of_ref_for_computer(), generate_receive_from_computer(), generate_send_to_computer(), generate_update_distributed_value_from_host(), generate_update_private_value_from_host(), generate_update_values_on_computer_and_nodes(), get_ith_dim_new_declaration(), init_host_and_node_entities(), NewDeclarationOfDistributedArray(), NewVariableForModule(), put_generated_resources_for_common(), set_similar_mappings_for_updates(), st_send_to_computer_if_necessary(), update_object_for_module(), and update_overlaps_in_caller().

Here is the caller graph for this function:

load_old_host()

entity load_old_host

(

entity

)

Referenced by debug_host_node_variables(), old_name(), and STATIC_LIST_OF_HPF_OBJECTS().

Here is the caller graph for this function:

load_old_node()

entity load_old_node

(

entity

)

Referenced by add_bound_arguments(), debug_host_node_variables(), old_name(), and STATIC_LIST_OF_HPF_OBJECTS().

Here is the caller graph for this function:

load_overlap_status()

list load_overlap_status

(

entity

)

Referenced by get_overlap(), and set_overlap().

Here is the caller graph for this function:

load_primary_entity()

entity load_primary_entity

(

entity

)

Referenced by add_as_a_modified_variable(), add_as_a_used_dynamic_to_statement(), add_as_a_used_variable(), add_declaration_to_host_and_link(), add_dynamic_synonym(), alive_arrays(), array_distribution_similar_p(), create_init_common_param_for_arrays(), generate_copy_loop_nest(), generate_dynamic_liveness_management(), generate_remapping_code(), generate_remapping_guard(), initialize_reaching_propagation(), new_synonym(), propagation_on_remapping_graph(), regenerate_renamings(), reinitialize_reaching_mappings(), remapping_file_name(), remove_from_entities(), remove_not_remapped_leavings(), safe_load_primary_entity(), same_primary_entity_p(), set_array_status_to_target(), and update_runtime_for_remapping().

Here is the caller graph for this function:

load_renamings()

list load_renamings

(

statement

)

Referenced by clean_statement(), initial_alignment(), initialize_reaching_propagation(), one_align_directive(), one_distribute_directive(), regenerate_renamings(), remapping_compile(), and root_statement_remapping_inits().

Here is the caller graph for this function:

load_similar_mapping()

entity load_similar_mapping

(

entity

)

Referenced by check_for_similarity(), create_parameters_h(), deal_with_similars(), generate_hpf_remapping_file(), hpfc_check_for_similarities(), set_live_status(), and set_similar_mappings_for_updates().

Here is the caller graph for this function:

load_statement_only_io()

bool load_statement_only_io

(

statement

)

Referenced by hpf_compiler().

Here is the caller graph for this function:

local_integer_constant_expression()

bool local_integer_constant_expression

(

expression

e

)

true is the expression is locally constant, that is in the whole loop nest, the reference is not written.

??? not very portable thru pips...

Definition at line 64 of file align-checker.c.

{
    syntax s = expression_syntax(e);
 
    if ((syntax_reference_p(s)) &&
        (normalized_linear_p(expression_normalized(e))))
    {
        entity ent = reference_variable(syntax_reference(s));
        if (write_on_entity_p(ent)) return false;
    }
    
    return true;
}

References expression_normalized, expression_syntax, normalized_linear_p, reference_variable, syntax_reference, syntax_reference_p, and write_on_entity_p().

Referenced by align_check(), and simple_indices_p().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_index_to_range()

range loop_index_to_range

(

entity

index

)

Parameters

index

ndex

Definition at line 390 of file compiler-util.c.

{
    MAP(LOOP, l, if (loop_index(l)==index) return(loop_range(l)),
        current_loop_list);
    return range_undefined;
}

References current_loop_list, LOOP, loop_index, loop_range, MAP, and range_undefined.

Referenced by array_access_to_array_ranges(), and generate_one_message().

Here is the caller graph for this function:

loop_nest_guard()

statement loop_nest_guard	(	statement	stat,
		reference	r,
		list	lkref,
		list	lvref
	)

??? memory leak of some expressions

Parameters

stat	tat
lkref	kref
lvref	vref

Definition at line 793 of file message-utils.c.

{
    entity
        array    = reference_variable(r),
        template = array_to_template(array),
        proc     = template_to_processors(template);
    list
        lra = array_access_to_array_ranges(r, lkref, lvref),
        lrt = array_ranges_to_template_ranges(array, lra),
        lrp = template_ranges_to_processors_ranges(template, lrt);
    statement
        result = generate_guarded_statement(stat, proc, lrp);
 
    gen_free_list(lra); /* ??? memory leak of some expressions */
    gen_free_list(lrt);
    gen_free_list(lrp);
 
    return(result);
}

References array, array_access_to_array_ranges(), array_ranges_to_template_ranges(), array_to_template, gen_free_list(), generate_guarded_statement(), reference_variable, template_ranges_to_processors_ranges(), and template_to_processors.

Referenced by Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

lrange_larger_p()

bool lrange_larger_p	(	list	lr1,
		list	lr2
	)

can look for formal equality...

??? something more intelligent could be expected

Parameters

lr1	r1
lr2	r2

Definition at line 381 of file message-utils.c.

{
    list l1 = lr1, l2 = lr2;
 
    assert(gen_length(lr1) == gen_length(lr2));
    
    for ( ; l1; POP(l1), POP(l2))
    {
        range r1 = RANGE(CAR(l1)), r2 = RANGE(CAR(l2));
        int lo1, up1, in1, lo2, up2, in2;
        bool
            blo1 = hpfc_integer_constant_expression_p(range_lower(r1), &lo1),
            bup1 = hpfc_integer_constant_expression_p(range_upper(r1), &up1),
            bin1 = hpfc_integer_constant_expression_p(range_increment(r1), &in1),
            blo2 = hpfc_integer_constant_expression_p(range_lower(r2), &lo2),
            bup2 = hpfc_integer_constant_expression_p(range_upper(r2), &up2),
            bin2 = hpfc_integer_constant_expression_p(range_increment(r2), &in2),
            bcst = (blo1 && bup1 && bin1 && blo2 && bup2 && bin2);
 
        if (!bcst) /* can look for formal equality... */
        {
            return(expression_equal_p(range_lower(r1), range_lower(r2)) &&
                   expression_equal_p(range_upper(r1), range_upper(r2)) &&
                   expression_equal_p(range_increment(r1), range_increment(r2)));
        }
 
        if (in1!=in2) return(false);
        
        /* ??? something more intelligent could be expected */
        if ((in1!=1) && ((lo1!=lo2) || (up1!=up2))) 
            return(false);
 
        if ((in1==1) && ((lo1>lo2) || (up1<up2)))
            return(false);
    }
 
    pips_debug(7, "returning TRUE\n");
 
    return true;
}

References assert, CAR, expression_equal_p(), gen_length(), hpfc_integer_constant_expression_p(), pips_debug, POP, RANGE, range_increment, range_lower, and range_upper.

Referenced by message_larger_p().

Here is the call graph for this function:

Here is the caller graph for this function:

lUpdateExpr()

list lUpdateExpr	(	entity	module,
		list	l
	)

Parameters

module	odule
l	of anything

Definition at line 256 of file host_node_entities.c.

{
    list new = gen_full_copy_list(l);
    update_list_for_module(new, module);    
    return new;
}

References gen_full_copy_list(), module, and update_list_for_module().

Referenced by generate_c1_beta(), hpf_compile_call(), st_compute_current_computer(), and st_compute_current_owners().

Here is the call graph for this function:

Here is the caller graph for this function:

lUpdateExpr_but_distributed()

list lUpdateExpr_but_distributed	(	entity	module,
		list	l
	)

used for compiling calls.

Parameters

module	odule
l	of expression

Definition at line 237 of file host_node_entities.c.

{
    list new = NIL;
 
    MAP(EXPRESSION, e,
    {
        if (!array_distributed_p(expression_to_entity(e)))
            new = CONS(EXPRESSION, copy_expression(e), new);
    },
        l);
 
    new = gen_nreverse(new);
    update_list_for_module(new, module);    
    return new;
}

References array_distributed_p(), CONS, copy_expression(), EXPRESSION, expression_to_entity(), gen_nreverse(), MAP, module, NIL, and update_list_for_module().

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

make_guard_expression()

bool make_guard_expression	(	entity	proc,
		list	lrref,
		expression *	pguard
	)

bool make_guard_expression(proc, lr, pguard)

compute the expression for the processors ranges lr guard. return true if not empty, false if empty.

empty match case

??? memory leak with the content of conjonction

MYPOS(i, procnum).EQ.nn

MYPOS(i, procnum).GE.(rloexpr)

MYPOS(i, procnum).LE.(rupexpr)

use of conjonction

no guard

Parameters

proc	roc
lrref	rref
pguard	guard

Definition at line 702 of file message-utils.c.

{
    int i, len = -1;
    expression procnum = int_to_expression(load_hpf_number(proc));
    list lr = lrref, conjonction = NIL;
    
    for (i=1 ; i<=NumberOfDimension(proc) ; i++, lr=CDR(lr))
    {
         range rg = RANGE(CAR(lr));
         expression
             rloexpr = range_lower(rg),
             rupexpr = range_upper(rg);
         dimension d = FindIthDimension(proc, i);
         int
             lo  = HpfcExpressionToInt(dimension_lower(d)),
             up  = HpfcExpressionToInt(dimension_upper(d)),
             sz  = up-lo+1,
             rlo = HpfcExpressionToInt(rloexpr),
             rup = HpfcExpressionToInt(rupexpr);
 
         if (rlo>rup) /* empty match case */
         {
             (*pguard) = entity_to_expression(entity_intrinsic(".FALSE."));
             return(true); /* ??? memory leak with the content of conjonction */
         }
 
         if ((rlo==rup) && (sz!=1) && (rlo>=lo) && (rup<=up))
         {
             /* MYPOS(i, procnum).EQ.nn
              */
             conjonction = 
                CONS(EXPRESSION,
                     eq_expression(make_mypos_expression(i, procnum), rloexpr),
                     conjonction);
         }
         else
         {
             if (rlo>lo)
             {
                 /* MYPOS(i, procnum).GE.(rloexpr)
                  */
                 conjonction =
                   CONS(EXPRESSION,
                     ge_expression(make_mypos_expression(i, procnum), rloexpr),
                        conjonction);
             }
 
             if (rup<up)
             {
                 /* MYPOS(i, procnum).LE.(rupexpr)
                  */
                 conjonction =
                   CONS(EXPRESSION,
                     le_expression(make_mypos_expression(i, procnum), rupexpr),
                        conjonction);
             }
         }
     }
    
    /* use of conjonction 
     */
 
    len = gen_length(conjonction);
 
    if (len==0) /* no guard */
    {
        (*pguard) = expression_undefined;
        return(false);
    }
    else
    {
        (*pguard) = expression_list_to_conjonction(conjonction);
        gen_free_list(conjonction);
        return(true);
    }
}

References CAR, CDR, CONS, dimension_lower, dimension_upper, entity_intrinsic(), entity_to_expression(), eq_expression, EXPRESSION, expression_list_to_conjonction(), expression_undefined, FindIthDimension(), ge_expression, gen_free_list(), gen_length(), HpfcExpressionToInt(), int_to_expression(), le_expression, load_hpf_number(), make_mypos_expression(), NIL, NumberOfDimension(), RANGE, range_lower, and range_upper.

Referenced by generate_guarded_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

make_host_and_node_modules()

void make_host_and_node_modules

(

entity

module

)

compile.c

HOST and NODE empty routines...

Arity and result

then the variable corresponding to the function name must be created for those new functions. The overloaded basic is used to be sure that the variable will not be put in the declarations by the enforced coherency. ??? this issue could be managed by the coherency function ?

to allow the update of the call sites.

Parameters

module

odule

Definition at line 45 of file compile.c.

{
    const char* name = entity_local_name(module);
    entity host, node;
 
    if (bound_new_node_p(module))
        return;
 
    if (entity_main_module_p(module))
    {
        host = make_empty_subroutine(HOST_NAME,make_language_fortran());
        node = make_empty_subroutine(NODE_NAME,make_language_fortran());
    }
    else
    {
        string tmp;
 
        /* HOST and NODE empty routines...
         */
        tmp = strdup(concatenate(name, "_", HOST_NAME, NULL));
        host = make_empty_subroutine(tmp,make_language_fortran());
        free(tmp);
 
        tmp = strdup(concatenate(name, "_", NODE_NAME, NULL));
        node = make_empty_subroutine(tmp,make_language_fortran());
        free(tmp);
 
        /*  Arity and result
         */
        update_functional_as_model(host, module);
        update_functional_as_model(node, module);
 
        if (entity_function_p(module))
        {
            /* then the variable corresponding to the function name
             * must be created for those new functions. The overloaded
             * basic is used to be sure that the variable will not be put 
             * in the declarations by the enforced coherency. 
             * ??? this issue could be managed by the coherency function ?
             */
            string
                var_name = concatenate(name, MODULE_SEP_STRING, name, NULL);
            entity
                var = gen_find_tabulated(var_name, entity_domain), neh, nen;
 
            pips_assert("defined", !entity_undefined_p(var));
 
            const char* tmp_name = entity_local_name(host);
            neh = find_or_create_scalar_entity(tmp_name, tmp_name, 
                                               is_basic_overloaded);
            tmp_name = entity_local_name(node);
            nen = find_or_create_scalar_entity(tmp_name, tmp_name, 
                                               is_basic_overloaded);
            store_new_host_node_variable(neh, nen, var);
        }               
    }
 
    /*  to allow the update of the call sites.
     */
    store_new_host_variable(host, module);
    store_new_node_variable(node, module);
}

References bound_new_node_p(), concatenate(), entity_domain, entity_function_p(), entity_local_name(), entity_main_module_p(), entity_undefined_p, find_or_create_scalar_entity(), free(), gen_find_tabulated(), HOST_NAME, is_basic_overloaded, make_empty_subroutine(), make_language_fortran(), module, MODULE_SEP_STRING, node(), NODE_NAME, pips_assert, store_new_host_node_variable(), store_new_host_variable(), store_new_node_variable(), strdup(), and update_functional_as_model.

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

make_hpfc_current_mappings()

void make_hpfc_current_mappings

(

void

)

??? used with a temporary hack to differentiate array and templates

Definition at line 192 of file build-system.c.

{
    make_declaration_constraints_map();
    make_hpf_align_constraints_map();
    make_hpf_distribute_constraints_map();
    make_new_declaration_constraints_map();
}

Referenced by set_resources_for_module().

Here is the caller graph for this function:

make_list_of_dummy_variables()

list make_list_of_dummy_variables	(	entity(*)(void)	,
		int
	)

make_mypos_expression()

expression make_mypos_expression	(	int	i,
		expression	exp
	)

Parameters

exp

xp

Definition at line 782 of file message-utils.c.

{
    return(reference_to_expression
           (make_reference(hpfc_name_to_entity(MYPOS),
                           CONS(EXPRESSION, int_to_expression(i),
                           CONS(EXPRESSION, exp,
                                NIL)))));
}

References CONS, exp, EXPRESSION, hpfc_name_to_entity(), int_to_expression(), make_reference(), MYPOS, NIL, and reference_to_expression().

Referenced by make_guard_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

make_only_io_map()

void make_only_io_map

(

void

)

make_rectangular_area()

list make_rectangular_area	(	statement	st,
		entity	var
	)

Parameters

st	t
var	ar

Definition at line 597 of file special_cases.c.

{
    list l = NIL;
    Psysteme
        s = sc_dup(get_read_effect_area(load_statement_local_regions(st),
                                         var));
    Pcontrainte c, lower = CONTRAINTE_UNDEFINED, upper = CONTRAINTE_UNDEFINED;
    Variable idx;
    entity div = hpfc_name_to_entity(IDIVIDE);
    int dim = gen_length(variable_dimensions(type_variable(entity_type(var))));
 
    sc_transform_eg_in_ineg(s);
    c = sc_inegalites(s);
    sc_inegalites(s) = (Pcontrainte)NULL, 
    sc_rm(s);
 
    for(; dim>0; dim--)
    {
        idx = (Variable) get_ith_region_dummy(dim);
 
        constraints_for_bounds(idx, &c, &lower, &upper);
 
        l = CONS(EXPRESSION, constraints_to_loop_bound(lower, idx, true, div),
            CONS(EXPRESSION, constraints_to_loop_bound(upper, idx, false, div),
                 l));
 
        (void) contraintes_free(lower), lower=NULL;
        (void) contraintes_free(upper), upper=NULL;
    }
 
    (void) contraintes_free(c);
    
    return l;
}

References CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED, contraintes_free(), entity_type, EXPRESSION, gen_length(), get_ith_region_dummy(), get_read_effect_area(), hpfc_name_to_entity(), IDIVIDE, load_statement_local_regions(), NIL, sc_dup(), sc_rm(), sc_transform_eg_in_ineg(), type_variable, and variable_dimensions.

Referenced by generate_subarray_shift().

Here is the call graph for this function:

Here is the caller graph for this function:

make_reference_expression()

expression make_reference_expression	(	entity	,
		entity(*)(void)
	)

make_update_common_map()

void make_update_common_map

(

void

)

Referenced by hpfc_directives_handler().

Here is the caller graph for this function:

MakeRunTimeSupportFunction()

entity MakeRunTimeSupportFunction	(	string	,
		int	,
		tag
	)

Referenced by make_reduction_function().

Here is the caller graph for this function:

MakeRunTimeSupportSubroutine()

entity MakeRunTimeSupportSubroutine	(	string	,
		int
	)

run-time.c

Referenced by hpfc_ith_broadcast_function(), make_new_reduction_function(), and make_shift_subroutine().

Here is the caller graph for this function:

MakeStatementLike()

statement MakeStatementLike	(	statement	stat,
		int	the_tag
	)

creates a new statement for the given module that looks like the stat one, i.e.

same comment, same label, and so on. The goto table is updated. The instruction is also created. (is that really a good idea?)

Parameters

stat	tat
the_tag	he_tag

Definition at line 203 of file hpfc-util.c.

{
    void* x = loop_undefined;
    string c = statement_comments(stat);
    statement new_s;
 
    if (the_tag==is_instruction_sequence)
        x = make_sequence(NIL);
 
 
    new_s = make_statement(statement_label(stat),
                           STATEMENT_NUMBER_UNDEFINED,
                           STATEMENT_ORDERING_UNDEFINED,
                           string_undefined_p(c)? c: strdup(c),
                           make_instruction(the_tag, x),NIL,NULL,
                           copy_extensions (statement_extensions(stat)), make_synchronization_none());
    fix_statement_attributes_if_sequence(new_s);
    return new_s;
}

References copy_extensions(), fix_statement_attributes_if_sequence(), is_instruction_sequence, loop_undefined, make_instruction(), make_sequence(), make_statement(), make_synchronization_none(), NIL, statement_comments, statement_extensions, statement_label, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, strdup(), string_undefined_p, and x.

Referenced by hpf_compile_block(), hpf_compile_call(), hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), hpf_compile_test(), and hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

max_size_of_processors()

int max_size_of_processors

(

void

)

Definition at line 120 of file inits.c.

{
    int current_max = 1;
 
    MAP(ENTITY, e, 
    {
        variable a;
        
        pips_assert("variable", type_variable_p(entity_type(e)));
        a = type_variable(entity_type(e));
        
        current_max = max(current_max,
                          element_number(variable_basic(a), variable_dimensions(a)));
    }, 
        list_of_processors());
 
    return current_max;
}

References current_max, element_number(), ENTITY, entity_type, list_of_processors(), MAP, max, pips_assert, type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by create_common_parameters_h().

Here is the call graph for this function:

Here is the caller graph for this function:

maybeuseful_mappings_undefined_p()

bool maybeuseful_mappings_undefined_p

(

void

)

message_larger_p()

bool message_larger_p	(	message	m1,
		message	m2
	)

bool message_larger_p(m1, m2)

true if m1>=m2... (caution, it is only a partial order)

Parameters

m1	1
m2	2

Definition at line 363 of file message-utils.c.

{
    if (message_array(m1)!=message_array(m2))
        return(false);
 
    if (value_ne(vect_coeff(TCST, (Pvecteur) message_neighbour(m1)),
                 vect_coeff(TCST, (Pvecteur) message_neighbour(m2))))
        return(false);
 
    /*
     * same array and same destination, let's look at the content and domain...
     */
 
    return(lrange_larger_p(message_content(m1), message_content(m2)) &&
           lrange_larger_p(message_dom(m1), message_dom(m2)));
}

References lrange_larger_p(), message_array, message_content, message_dom, message_neighbour, TCST, value_ne, and vect_coeff().

Referenced by larger_message_in_list().

Here is the call graph for this function:

Here is the caller graph for this function:

messages_handling()

statement messages_handling	(	list	Ro,
		list	lRo
	)

messages.c

messages.c

first kind of messages generation

a message is an array, a mixed content on the local array, a set of neighbours (in a Pvecteur) and an array section concerned.

here should be performed some message coalescing and/or aggregation: a first simple version could check for messages sent twice, and so on.

RECEIVE

Parameters

Ro	o
lRo	Ro

Definition at line 724 of file messages.c.

{
    list
        lm1  = NIL,
        lm2  = NIL,
        lm2p = NIL,
        lm3  = NIL,
        lm3p = NIL,
        lm4  = NIL,
        lms  = NIL,
        lmr  = NIL,
        lsend = NIL,
        lreceive = NIL;
    int
        len = gen_length(Ro);
    
    assert(len==(int)gen_length(lRo) && len>=1);
 
    /* first kind of messages generation
     *
     * a message is 
     * an array,
     * a mixed content on the local array,
     * a set of neighbours (in a Pvecteur) and
     * an array section concerned.
     */
    lm1 = messages_generation(Ro, lRo);
 
    debug(6, "messages_handling", "lm1 length is %d\n", gen_length(lm1));
    ifdebug(8)
    {
        fprint_lmessage(stderr, lm1);
    }
 
    /*
     * second kind of messages generation
     *
     * messages are atomized to real messages:
     * a message is 
     * an array, 
     * a content (on the local array),
     * a neighbour to send to (in a Pvecteur),
     * a domain of the array concerned.
     */
    lm2 = messages_atomization(lm1);
    gen_free_list(lm1);
 
    debug(6, "messages_handling",
          "lm2 length is %d\n", gen_length(lm2));
    ifdebug(8)
    {
        fprint_lmessage(stderr, lm2);
    }
 
    lm2p = keep_non_empty_messages_with_destination(lm2);
    gen_free_list(lm2);
 
    debug(6, "messages_handling",
          "lm2p length is %d\n", gen_length(lm2p));
    ifdebug(8)
    {
        fprint_lmessage(stderr, lm2p);
    }
 
 
    /*
     * third kind of messages generation
     *
     * the domain is restricted to what is necessary for the
     * given message, and this on every distributed dimension...
     * this is important for the guards generation later on.
     */
    lm3 = messages_shaping(lm2p);
    gen_free_list(lm2p);
 
    debug(6, "messages_handling",
          "lm3 length is %d\n", gen_length(lm3));
    ifdebug(8)
    {
        fprint_lmessage(stderr, lm3);
    }
 
 
    lm3p = keep_non_empty_domain_messages(lm3);
    gen_free_list(lm3);
 
    debug(6, "messages_handling", "lm3p length is %d\n", gen_length(lm3p));
    ifdebug(8) fprint_lmessage(stderr, lm3p);
 
    /*
     * fourth kind of messages generation
     * 
     * the array section domain is translated into a processors section,
     * and the neighbour shift is computed for the linearized processors 
     * arrangement considered in the runtime resolution.
     */
    lm4 = messages_guards_and_neighbour(lm3p);
    gen_free_list(lm3p);
    
    debug(6, "messages_handling", "lm4 length is %d\n", gen_length(lm4));
    ifdebug(8) fprint_lmessage(stderr, lm4);
 
    /* here should be performed some message coalescing and/or aggregation:
     * a first simple version could check for messages sent twice, and so on.
     */
    hpfc_warning("messages coalescing and aggregation not implemented\n");
 
    lms = remove_stammering_messages(lm4);
 
    /*  RECEIVE 
     */
    lmr = receive_messages_generation(lms);
 
    assert(gen_length(lmr)==gen_length(lms));
 
    ifdebug(8)
    {
        fprintf(stderr, "[message handling] lmr and lms\n");
        fprint_lmessage(stderr, lmr);
        fprint_lmessage(stderr, lms);
    }
 
    lsend = generate_the_messages(lms, SEND);
    lreceive = generate_the_messages(lmr, RECEIVE);
 
    return(make_block_statement(gen_nconc(lsend, lreceive)));    
}

References assert, debug(), fprint_lmessage(), fprintf(), gen_free_list(), gen_length(), gen_nconc(), generate_the_messages(), hpfc_warning, ifdebug, keep_non_empty_domain_messages(), keep_non_empty_messages_with_destination(), make_block_statement(), messages_atomization(), messages_generation(), messages_guards_and_neighbour(), messages_shaping(), NIL, RECEIVE, receive_messages_generation(), remove_stammering_messages(), and SEND.

Referenced by Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

new_align_with_template()

align new_align_with_template	(	align	a,
		entity	t
	)

Definition at line 474 of file dynamic.c.

{
    align b = copy_align(a);
    align_template(b) = t;
    return b;
}

References align_template, and copy_align().

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_declaration_tag()

tag new_declaration_tag	(	entity	array,
		int	dim
	)

Parameters

array	rray
dim	im

Definition at line 229 of file declarations.c.

{
    tag t;
 
    pips_assert("valid dimension and distributed array",
                dim>0 && dim<=7 && array_distributed_p(array));
 
    t = hpf_newdecl_tag
        (HPF_NEWDECL(gen_nth(dim-1, 
         hpf_newdecls_dimensions(load_new_declaration(array)))));
 
    pips_debug(1, "%s[%d]: %d\n", entity_name(array), dim, t);
 
    return(t);
}

References array, array_distributed_p(), entity_name, gen_nth(), HPF_NEWDECL, hpf_newdecl_tag, hpf_newdecls_dimensions, pips_assert, and pips_debug.

Referenced by block_distributed_p(), create_init_common_param_for_arrays(), expr_compute_local_index(), and hpfc_compute_entity_to_new_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

new_host_undefined_p()

bool new_host_undefined_p

(

void

)

host_node_entities.c

new_node_undefined_p()

bool new_node_undefined_p

(

void

)

NewDeclarationsOfDistributedArrays()

void NewDeclarationsOfDistributedArrays

(

void

)

this procedure generate the new declarations of every distributed arrays of the program, in order to minimize the amount of memory used.

The new declarations have to be suitable for the new index computation which is to be done dynamically...

Definition at line 676 of file declarations.c.

{
    MAP(ENTITY, array,
    {
        if (!bound_new_declaration_p(array))
            NewDeclarationOfDistributedArray(array);
        else
            pips_debug(3, "skipping array %s\n", entity_name(array));
    },
        list_of_distributed_arrays());
}

References array, ENTITY, entity_name, list_of_distributed_arrays(), MAP, NewDeclarationOfDistributedArray(), and pips_debug.

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

NewVariableForModule()

entity NewVariableForModule	(	entity	module,
		entity	e
	)

Parameters

module

odule

Definition at line 283 of file host_node_entities.c.

{
    if (module==host_module)
    {
        if (bound_new_host_p(e)) 
            return load_new_host(e);
    }
    else
    {
        if (bound_new_node_p(e))
            return load_new_node(e);
    }
 
    pips_internal_error("unexpected entity %s", entity_name(e));
 
    return entity_undefined;
}

References bound_new_host_p(), bound_new_node_p(), entity_name, entity_undefined, host_module, load_new_host(), load_new_node(), module, and pips_internal_error.

Referenced by hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), and lNewVariableForModule().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_align()

void normalize_align	(	entity	,
		align
	)

normalize_distribute()

void normalize_distribute	(	entity	t,
		distribute	d
	)

of distribution

Definition at line 408 of file declarations.c.

{
    entity p = distribute_processors(d);
    list /* of distribution */ ld = distribute_distribution(d);
    int tdim = 1, pdim = 1;
 
    normalize_first_expressions_of(d);
    
    MAP(DISTRIBUTION, di,
        NormalizeOneTemplateDistribution(di, t, &tdim, p, &pdim), ld);
 
    if ((pdim-1)!=NumberOfDimension(p))
        pips_user_error("%s not enough distributions\n", entity_name(t));
                   
}

References distribute_distribution, distribute_processors, DISTRIBUTION, entity_name, MAP, normalize_first_expressions_of(), NormalizeOneTemplateDistribution(), NumberOfDimension(), and pips_user_error.

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_hpf_object()

void normalize_hpf_object

(

entity

v

)

Definition at line 431 of file declarations.c.

{
    normalize_first_expressions_of(entity_type(v));
}

References entity_type, and normalize_first_expressions_of().

Here is the call graph for this function:

NormalizeCodeForHpfc()

void NormalizeCodeForHpfc

(

statement

s

)

reference test

function call test

test condition test

range test

whileloop test

Definition at line 848 of file compile.c.

{
    extract_distributed_non_constant_terms(s);
    normalize_all_expressions_of(s);
    atomize_as_required(s, 
                        hpfc_decision,      /* reference test */
                        (bool(*)(call,expression)) gen_false2,          /* function call test */
                        (bool(*)(test,expression)) test_atomization,/* test condition test */
                        (bool(*)(range,expression)) gen_false2,          /* range test */
                        (bool(*)(whileloop,expression)) gen_false2,          /* whileloop test */
                        hpfc_new_variable);
}

References atomize_as_required(), extract_distributed_non_constant_terms(), gen_false2(), hpfc_decision(), hpfc_new_variable(), normalize_all_expressions_of(), and test_atomization().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeCommonVariables()

void NormalizeCommonVariables	(	entity	module,
		statement	stat
	)

the new entities for the common variables are created and inserted in the common. The declarations are updated.

the references within the program are updated with the new entities

Parameters

module	odule
stat	tat

Definition at line 940 of file compile.c.

{
    list ldecl = code_declarations(entity_code(module)), lnewdecl = NIL, ltmp;
    entity common, new_e;
 
    /* the new entities for the common variables are created and
     * inserted in the common. The declarations are updated.
     */
    MAP(ENTITY, e,
    {
        if (entity_in_common_p(e))
        {
            common = ram_section(storage_ram(entity_storage(e)));
            new_e = AddEntityToModule(e, common);
            ltmp = area_layout(type_area(entity_type(common)));
            
            if (gen_find_eq(new_e, ltmp)==entity_undefined)
                gen_insert_after(new_e, e, ltmp);
            
            lnewdecl = CONS(ENTITY, new_e, lnewdecl);
            store_entity_update_common(e, new_e);
            
            pips_debug(8, "module %s: %s -> %s\n",
                  entity_name(module), entity_name(e), entity_name(new_e));
        }
        else
            lnewdecl = CONS(ENTITY, e, lnewdecl);
    },
        ldecl);
 
    gen_free_list(ldecl);
    code_declarations(entity_code(module)) = lnewdecl;
 
    /* the references within the program are updated with the new entities
     */
    update_common_references_in_obj(stat);
}

References AddEntityToModule(), area_layout, code_declarations, CONS, ENTITY, entity_code(), entity_in_common_p(), entity_name, entity_storage, entity_type, entity_undefined, gen_find_eq(), gen_free_list(), gen_insert_after(), MAP, module, NIL, pips_debug, ram_section, storage_ram, store_entity_update_common(), type_area, and update_common_references_in_obj().

Referenced by hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeHpfDeclarations()

void NormalizeHpfDeclarations

(

void

)

Definition at line 437 of file declarations.c.

{
    GiveToHpfObjectsTheirNumber();
    ifdebug(8){print_hpf_dir();}
}

References GiveToHpfObjectsTheirNumber(), ifdebug, and print_hpf_dir().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_distributed_arrays()

int number_of_distributed_arrays

(

void

)

declarations.c

Referenced by create_common_parameters_h().

Here is the caller graph for this function:

number_of_processors()

int number_of_processors

(

void

)

Referenced by create_common_parameters_h().

Here is the caller graph for this function:

number_of_templates()

int number_of_templates

(

void

)

Referenced by create_common_parameters_h().

Here is the caller graph for this function:

old_host_undefined_p()

bool old_host_undefined_p

(

void

)

old_node_undefined_p()

bool old_node_undefined_p

(

void

)

only_io_map_undefined_p()

bool only_io_map_undefined_p

(

void

)

io-util.c

only_io_mapping_initialize()

void only_io_mapping_initialize

(

statement

program

)

Parameters

program

rogram

Definition at line 163 of file io-util.c.

{
    debug_on("HPFC_IO_DEBUG_LEVEL");
    set_only_io_map(only_io_mapping(program, MAKE_STATEMENT_MAPPING()));
    debug_off();
}

References debug_off, debug_on, MAKE_STATEMENT_MAPPING, only_io_mapping(), and set_only_io_map().

Referenced by set_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

Overlap_Analysis()

bool Overlap_Analysis	(	statement	stat,
		statement *	pstat
	)

check conditions and compile...

keeps only written references of which dimensions are block distributed, and indices simple enough (=> normalization of loops may be usefull). ??? bug: should also search for A(i,i) things that are forbidden...

ok distributed variable written !

must chose the computer among read references!

??? what about loop splitting

??? memory leak

??? memory leak

Now, we have the following situation: Wa: set of aligned written refs, the first of which is `‘the’' ref.

here is the situation now:

Wa set of aligned references written, Ra set of aligned references read, Ro set of nearly aligned references that suits the overlap analysis

messages handling

generate the local loop for every processor, given the global loop bounds. The former indexes have to be computed, and the loops are based upon new indexes, of which names have to be propagated in the body of the loop. This generation is to be based on the normalized form computed for every references of Ro, but it is direct for Ra and Wa, since new declarations implied that the alignment is performed for distributed indices. Not distributed dimensions indices have not to be touched, (at least if no new declarations are the common case)

Parameters

stat	tat
pstat	stat

Definition at line 870 of file o-analysis.c.

{
    list lw = NIL, lr = NIL, Ra = NIL, Ro = NIL, Rrt = NIL,
        lWa = NIL, lRa = NIL, lRo = NIL, W  = NIL, Wa = NIL, 
        Wrt = NIL, lvect = NIL, lkind = NIL, R=NIL;
    syntax the_computer_syntax = syntax_undefined;
    reference the_computer_reference = reference_undefined;
    statement innerbody, messages_stat, newloopnest;
    bool computer_is_written = true;
 
    DEBUG_STAT(9, "considering statement", stat);
 
    set_hpfc_current_statement(stat);
    set_current_loops(stat);
 
    lblocks = NIL,
    lloop = NIL;
    innerbody = parallel_loop_nest_to_body(stat, &lblocks, &lloop);
 
    FindRefToDistArrayInStatement(stat, &lw, &lr);
 
    /* keeps only written references of which dimensions are block distributed,
     * and indices simple enough (=> normalization of loops may be usefull).
     * ??? bug: should also search for A(i,i) things that are forbidden...
     */
    MAP(SYNTAX, s,
    {
        reference r = syntax_reference(s);
        entity array = reference_variable(r);
        
        if ((block_distributed_p(array)) && 
            (simple_indices_p(r)) && (!replicated_p(array)))
            W = CONS(SYNTAX, s, W);
        else
            Wrt = CONS(SYNTAX, s, Wrt);
    },
        lw);
 
    pips_debug(9, "choosing computer\n");
 
    if (W) /* ok distributed variable written ! */
    {
        the_computer_syntax = choose_one_syntax_in_references_list(&W);
        the_computer_reference = syntax_reference(the_computer_syntax);
        Wa = CONS(SYNTAX, the_computer_syntax, NIL);
    }
    else  /* must chose the computer among read references! */
    {
        computer_is_written = false;
 
        MAP(SYNTAX, s,
        {
            reference r = syntax_reference(s);
            entity array = reference_variable(r);
        
            if ((block_distributed_p(array)) && 
                (simple_indices_p(r)) && (!replicated_p(array)))
                R = CONS(SYNTAX, s, R);
        },
            lr);
 
        if (R) 
        {
            the_computer_syntax = choose_one_syntax_in_references_list(&R);
            the_computer_reference = syntax_reference(the_computer_syntax);
            Ra = CONS(SYNTAX, the_computer_syntax, NIL);
        }
        else
            RETURN(false); 
    }
 
    if (!align_check(the_computer_reference,
                     the_computer_reference, &lvect, &lkind))
        pips_internal_error("no self alignment!");
 
    if (computer_is_written)
      lWa = CONS(LIST, CONS(LIST, lkind, CONS(LIST, lvect, NIL)), NIL);
    else
      lRa = CONS(LIST, CONS(LIST, lkind, CONS(LIST, lvect, NIL)), NIL);
 
    pips_debug(9, "checking alignments\n");
 
    MAP(SYNTAX, s,
    {
        reference r = syntax_reference(s);
        if (the_computer_reference==r) 
          continue;
        if (align_check(the_computer_reference, r, &lvect, &lkind))
        {
            if (aligned_p(the_computer_reference, r, lvect, lkind))
            {
                Wa = gen_nconc(Wa, CONS(SYNTAX, s, NIL));
                lWa = gen_nconc(lWa, CONS(LIST,
                                          CONS(LIST, lkind, 
                                               CONS(LIST, lvect, NIL)),
                                          NIL));
            }
            else /* ??? what about loop splitting */
            {
                Wrt = gen_nconc(Wrt, CONS(SYNTAX, s, NIL));
                gen_free_list(lvect);
                gen_free_list(lkind); /* ??? memory leak */
            }
            }
        else
        {
            Wrt = gen_nconc(Wrt, CONS(SYNTAX, s, NIL));
            gen_free_list(lvect);
            gen_free_list(lkind); /* ??? memory leak */
        }
    },
        W);
 
    pips_debug(5, "Wa length is %zd (%zd), Wrt lenght is %zd\n",
               gen_length(Wa), gen_length(lWa), gen_length(Wrt));
 
    if (gen_length(Wrt)!=0) 
        RETURN(false);
 
    /* Now, we have the following situation:
     * Wa: set of aligned written refs, the first of which is ``the'' ref.
     */
    MAP(SYNTAX, s,
     {
         reference r = syntax_reference(s);
         entity array = reference_variable(r);
         list lvect = NIL;
         list lkind = NIL;
 
         if (the_computer_reference==r) continue;
 
         pips_debug(6, "dealing with reference of array %s\n",
                    entity_name(array));
 
         ifdebug(6)
         {
             fprintf(stderr, "[Overlap_Analysis]\nreference is:\n");
             print_reference(r);
             fprintf(stderr, "\n");
         }
 
         if (align_check(the_computer_reference, r, &lvect, &lkind))
         {
             if (aligned_p(the_computer_reference, r, lvect, lkind))
             {
                 Ra = gen_nconc(Ra, CONS(SYNTAX, s, NIL));
                 lRa = gen_nconc(lRa, CONS(LIST,
                                           CONS(LIST, lkind,
                                                CONS(LIST, lvect, NIL)),
                                           NIL));
             }
             else
             if (message_manageable_p(array, lvect, lkind))
             {
                 Ro = gen_nconc(Ro, CONS(SYNTAX, s, NIL));
                 lRo = gen_nconc(lRo, CONS(LIST,
                                           CONS(LIST, lkind, 
                                                CONS(LIST, lvect, NIL)),
                                           NIL));
             }
             else
             {
                 Rrt = gen_nconc(Rrt, CONS(SYNTAX, s, NIL));
                 gen_free_list(lvect);
                 gen_free_list(lkind);
             }
         }
         else
         {
             Rrt = gen_nconc(Rrt, CONS(SYNTAX, s, NIL));
             gen_free_list(lvect);
             gen_free_list(lkind);
         }
     },
         lr);
 
    debug(5, "Overlap_Analysis",
          "Ra length is %d, Ro length is %d, Rrt lenght is %d\n",
          gen_length(Ra), gen_length(Ro), gen_length(Rrt));
 
    if (gen_length(Rrt)!=0) 
        RETURN(false);
 
    /* here is the situation now:
     *
     * Wa set of aligned references written,
     * Ra set of aligned references read,
     * Ro set of nearly aligned references that suits the overlap analysis
     */
 
    /* messages handling
     */
    messages_stat = ((gen_length(Ro)>0)?
                     (messages_handling(Ro, lRo)):
                     (make_continue_statement(entity_empty_label())));
 
    /* generate the local loop for every processor, given the global loop
     * bounds. The former indexes have to be computed, and the loops are
     * based upon new indexes, of which names have to be propagated in the
     * body of the loop. This generation is to be based on the normalized
     * form computed for every references of Ro, but it is direct for
     * Ra and Wa, since new declarations implied that the alignment is
     * performed for distributed indices. Not distributed dimensions
     * indices have not to be touched, (at least if no new declarations are
     * the common case)
     */
    if (!generate_optimized_code_for_loop_nest
        (innerbody, &newloopnest, the_computer_syntax, 
         Wa, Ra, Ro, lWa, lRa, lRo))
        RETURN(false);
 
    DEBUG_STAT(9, entity_name(node_module), newloopnest);
 
    (*pstat) =
        make_block_statement
            (CONS(STATEMENT, messages_stat,
             CONS(STATEMENT,
                  loop_nest_guard(newloopnest,
                                  the_computer_reference,
                  CONSP(CAR(CONSP(CAR(computer_is_written? lWa: lRa)))),
                  CONSP(CAR(CDR(CONSP(CAR(computer_is_written? lWa: lRa)))))),
                  NIL)));
 
    DEBUG_STAT(8, entity_name(node_module), *pstat);
 
    RETURN(true);
}

References align_check(), aligned_p(), array, block_distributed_p(), CAR, CDR, choose_one_syntax_in_references_list(), CONS, CONSP, debug(), DEBUG_STAT, entity_empty_label(), entity_name, FindRefToDistArrayInStatement(), fprintf(), gen_free_list(), gen_length(), gen_nconc(), generate_optimized_code_for_loop_nest(), ifdebug, lblocks, LIST, lloop, loop_nest_guard(), lvect, make_block_statement(), make_continue_statement(), MAP, message_manageable_p(), messages_handling(), NIL, node_module, parallel_loop_nest_to_body(), pips_debug, pips_internal_error, print_reference(), reference_undefined, reference_variable, replicated_p(), RETURN, set_current_loops(), set_hpfc_current_statement(), simple_indices_p(), STATEMENT, SYNTAX, syntax_reference, and syntax_undefined.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

overlap_status_undefined_p()

bool overlap_status_undefined_p

(

void

)

parallel_loop_nest_to_body()

statement parallel_loop_nest_to_body	(	statement	loop_nest,
		list *	pblocks,
		list *	ploops
	)

nothing was done for the first !

Parameters

loop_nest	oop_nest
pblocks	blocks
ploops	loops

Definition at line 336 of file compiler-util.c.

{
    loops=NIL, n_loops=0;
    blocks=NIL, n_levels=0;
    inner_body=statement_undefined;
 
    pips_assert("loop", instruction_loop_p(statement_instruction(loop_nest)));
 
    gen_multi_recurse(loop_nest,
                      sequence_domain, gen_true, sequence_rewrite,
                      loop_domain, loop_filter, loop_rewrite,
                      NULL);
 
    pips_assert("loops found", n_loops!=0 && (n_loops-n_levels==1));
 
    *pblocks = CONS(LIST, NIL, blocks); /* nothing was done for the first ! */
    *ploops=loops;
 
    return(inner_body);
}

References blocks, CONS, gen_multi_recurse(), gen_true(), inner_body, instruction_loop_p, LIST, loop_domain, loop_filter(), loop_rewrite(), loops, n_levels, n_loops, NIL, pips_assert, sequence_domain, sequence_rewrite(), statement_instruction, and statement_undefined.

Referenced by full_copy_p(), and Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

primary_entity_undefined_p()

bool primary_entity_undefined_p

(

void

)

print_align()

void print_align

(

align

a

)

debug-util.c

debug-util.c

Fabien Coelho, May 1993.

Definition at line 38 of file debug-util.c.

{
    (void) fprintf(stderr, "aligned (%zd dimensions)\n", 
                   gen_length(align_alignment(a)));
    gen_map((gen_iter_func_t)print_alignment, align_alignment(a));
    (void) fprintf(stderr, "to template %s\n\n",
                   entity_name(align_template(a)));
}

References align_alignment, align_template, entity_name, fprintf(), gen_length(), gen_map(), and print_alignment().

Referenced by array_synonym_aligned_as(), ComputeNewSizeOfIthDimension(), one_align_directive(), and print_aligns().

Here is the call graph for this function:

Here is the caller graph for this function:

print_alignment()

void print_alignment

(

alignment

a

)

Definition at line 47 of file debug-util.c.

{
    (void) fprintf(stderr,
                   "Alignment: arraydim %"PRIdPTR", templatedim %"PRIdPTR",\n",
                   alignment_arraydim(a),
                   alignment_templatedim(a));
    
    (void) fprintf(stderr,"rate: ");
    print_expression(alignment_rate(a));
    (void) fprintf(stderr,"\nconstant: ");
    print_expression(alignment_constant(a));
    (void) fprintf(stderr,"\n");
}

References alignment_arraydim, alignment_constant, alignment_rate, alignment_templatedim, fprintf(), and print_expression().

Referenced by print_align().

Here is the call graph for this function:

Here is the caller graph for this function:

print_aligns()

void print_aligns

(

void

)

Definition at line 61 of file debug-util.c.

{
    fprintf(stderr,"Aligns:\n");
    MAP(ENTITY, a,
     {
         (void) fprintf(stderr, "of array %s\n", entity_name(a));
         print_align(load_hpf_alignment(a));
         (void) fprintf(stderr,"\n");
     },
        list_of_distributed_arrays());
}

References ENTITY, entity_name, fprintf(), list_of_distributed_arrays(), load_hpf_alignment(), MAP, and print_align().

Referenced by print_hpf_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

print_distribute()

void print_distribute

(

distribute

d

)

Definition at line 87 of file debug-util.c.

{
    (void) fprintf(stderr,"distributed\n");
 
    gen_map((gen_iter_func_t)print_distribution, distribute_distribution(d));
 
    (void) fprintf(stderr, "to processors %s\n\n", 
                   entity_name(distribute_processors(d)));    
}

References distribute_distribution, distribute_processors, entity_name, fprintf(), gen_map(), and print_distribution().

Referenced by ComputeNewSizeOfIthDimension(), and print_distributes().

Here is the call graph for this function:

Here is the caller graph for this function:

print_distributed_arrays()

void print_distributed_arrays

(

void

)

Definition at line 148 of file debug-util.c.

{
    (void) fprintf(stderr,"Distributed Arrays:\n");
    gen_map((gen_iter_func_t)print_entity_variable, list_of_distributed_arrays());
}

References fprintf(), gen_map(), list_of_distributed_arrays(), and print_entity_variable().

Referenced by print_hpf_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

print_distributes()

void print_distributes

(

void

)

Definition at line 73 of file debug-util.c.

{
    fprintf(stderr,"Distributes:\n");
 
    MAP(ENTITY, t,
     {
         (void) fprintf(stderr, "of template %s\n", entity_name(t));
         print_distribute(load_hpf_distribution(t));
         (void) fprintf(stderr,"\n");
     },
         list_of_templates());
    
}

References ENTITY, entity_name, fprintf(), list_of_templates(), load_hpf_distribution(), MAP, and print_distribute().

Referenced by print_hpf_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

print_distribution()

void print_distribution

(

distribution

d

)

Definition at line 97 of file debug-util.c.

{
    switch(style_tag(distribution_style(d)))
    {
    case is_style_none:
        (void) fprintf(stderr,"none, ");
        break;
    case is_style_block:
        (void) fprintf(stderr,"BLOCK(");
        print_expression(distribution_parameter(d));
        (void) fprintf(stderr,"), ");
        break;
    case is_style_cyclic:
        (void) fprintf(stderr,"CYCLIC(");
        print_expression(distribution_parameter(d));
        (void) fprintf(stderr,"), ");
        break;
    default:
        pips_internal_error("unexpected style tag");
        break;
    }
    (void) fprintf(stderr,"\n");
}

References distribution_parameter, distribution_style, fprintf(), is_style_block, is_style_cyclic, is_style_none, pips_internal_error, print_expression(), and style_tag.

Referenced by print_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

print_hpf_dir()

void print_hpf_dir

(

void

)

Definition at line 121 of file debug-util.c.

{
    (void) fprintf(stderr,"HPF directives:\n");
 
    print_templates();
    (void) fprintf(stderr,"--------\n");
    print_processors();
    (void) fprintf(stderr,"--------\n");
    print_distributed_arrays();
    (void) fprintf(stderr,"--------\n");
    print_aligns();
    (void) fprintf(stderr,"--------\n");
    print_distributes();
}

References fprintf(), print_aligns(), print_distributed_arrays(), print_distributes(), print_processors(), and print_templates().

Referenced by NormalizeHpfDeclarations().

Here is the call graph for this function:

Here is the caller graph for this function:

print_processors()

void print_processors

(

void

)

Definition at line 142 of file debug-util.c.

{
    (void) fprintf(stderr,"Processors:\n");
    gen_map((gen_iter_func_t)print_entity_variable, list_of_processors());
}

References fprintf(), gen_map(), list_of_processors(), and print_entity_variable().

Referenced by print_hpf_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

print_templates()

void print_templates

(

void

)

Definition at line 136 of file debug-util.c.

{
    (void) fprintf(stderr,"Templates:\n");
    gen_map((gen_iter_func_t)print_entity_variable, list_of_templates());
}

References fprintf(), gen_map(), list_of_templates(), and print_entity_variable().

Referenced by print_hpf_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

processor_dimension_of_template_dimension()

int processor_dimension_of_template_dimension	(	entity	template,
		int	dim
	)

Parameters

template	emplate
dim	im

Definition at line 462 of file hpfc-util.c.

{
    int pdim = 0, n;
    if (dim>=0) get_distribution(template, dim, &pdim, &n);
    return pdim;
}

References get_distribution().

Here is the call graph for this function:

processor_number()

int processor_number	(	entity	template,
		int	tdim,
		int	tcell,
		int *	pprocdim
	)

int processor_number(template, tdim, tcell, pprocdim)

the processor number of a template cell, on dimension *pprocdim template dimension, template cell

just to avoid a gcc warning

Parameters

template	emplate
tdim	dim
tcell	cell
pprocdim	procdim

Definition at line 492 of file hpfc-util.c.

{
    distribute d = load_hpf_distribution(template);
    list ld = distribute_distribution(d);
    entity procs = distribute_processors(d);
    distribution di = FindDistributionOfDim(ld, tdim, pprocdim);
    style st = distribution_style(di);
    int n, tmin, pmin, psiz;
 
    if (style_none_p(st))
    {
        *pprocdim = -1;
        return -1;
    }
 
    tmin = HpfcExpressionToInt
        (dimension_lower(FindIthDimension(template, tdim)));
    pmin = HpfcExpressionToInt
        (dimension_lower(FindIthDimension(procs, *pprocdim)));
    psiz = SizeOfIthDimension(procs, *pprocdim);
    n    = HpfcExpressionToInt(distribution_parameter(di));
 
    if (style_block_p(st))
        return ((tcell-tmin)/n)+pmin;
 
    if (style_cyclic_p(st))
        return (((tcell-tmin)/n)%psiz)+pmin;
 
    *pprocdim = -1; /* just to avoid a gcc warning */
    return -1; 
}    

References dimension_lower, distribute_distribution, distribute_processors, distribution_parameter, distribution_style, FindDistributionOfDim(), FindIthDimension(), HpfcExpressionToInt(), load_hpf_distribution(), SizeOfIthDimension(), style_block_p, style_cyclic_p, and style_none_p.

Referenced by aligned_p(), on_same_proc_p(), and template_ranges_to_processors_ranges().

Here is the call graph for this function:

Here is the caller graph for this function:

processors_dim_replicated_p()

bool processors_dim_replicated_p	(	entity	,
		entity	,
		int
	)

propagate_synonym()

void propagate_synonym	(	statement	s,
		entity	old,
		entity	new,
		bool	is_array
	)

Parameters

old	ld
new	ew
is_array	s_array

Definition at line 1096 of file dynamic.c.

{
    statement current;
 
    what_stat_debug(3, s);
    pips_debug(3, "%s -> %s (%s)\n", entity_name(old), entity_name(new),
               is_array? "array": "template");
    DEBUG_STAT(7, "before propagation", get_current_module_statement());
 
    old_variable = safe_load_primary_entity(old), new_variable = new, 
    array_propagation = is_array;
    array_used = false;
    array_modified = false;
    initial_statement = s;
 
    lazy_initialize_for_statement(s);
 
    init_ctrl_graph_travel(s, continue_propagation_p);
 
    while (next_ctrl_graph_travel(&current))
        simple_switch_old_to_new(current);
 
    close_ctrl_graph_travel();
 
    if (array_used) add_as_a_used_variable(old);
    if (array_modified) add_as_a_modified_variable(old);
 
    old_variable = entity_undefined, 
    new_variable = entity_undefined;
 
    DEBUG_STAT(7, "after propagation", get_current_module_statement());
 
    pips_debug(4, "out\n");
}

References add_as_a_modified_variable(), add_as_a_used_variable(), array_modified, array_propagation, array_used, close_ctrl_graph_travel(), continue_propagation_p(), current, DEBUG_STAT, entity_name, entity_undefined, get_current_module_statement(), init_ctrl_graph_travel(), initial_statement, lazy_initialize_for_statement(), new_variable, next_ctrl_graph_travel(), old_variable, pips_debug, safe_load_primary_entity(), simple_switch_old_to_new(), and what_stat_debug.

Referenced by handle_prescriptive_directive(), initial_alignment(), one_align_directive(), and one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

put_generated_resources_for_common()

void put_generated_resources_for_common

(

entity

common

)

Parameters

common

ommon

Definition at line 417 of file compile.c.

{
    FILE *host_file, *node_file, *parm_file, *init_file;
    string host_name, node_name, parm_name, init_name, dir_name;
    entity node_common, host_common;
 
    node_common = load_new_node(common),
    host_common = load_new_host(common);
    const char *prefix = module_local_name(common);
    dir_name = db_get_current_workspace_directory();
    
    host_name = src(prefix, HINC_SUFFIX);
    node_name = src(prefix, NINC_SUFFIX);
    parm_name = src(prefix, PARM_SUFFIX);
    init_name = src(prefix, INIT_SUFFIX);
 
    host_file = hpfc_fopen(full_name(dir_name, host_name));
    hpfc_print_common(host_file, host_module, host_common);
    hpfc_fclose(host_file, host_name);
 
    node_file = hpfc_fopen(full_name(dir_name, node_name));
    hpfc_print_common(node_file, node_module, node_common);
    hpfc_fclose(node_file, node_name);
 
    parm_file = hpfc_fopen(full_name(dir_name, parm_name));
    create_parameters_h(parm_file, common);
    hpfc_fclose(parm_file, parm_name);
 
    init_file = hpfc_fopen(full_name(dir_name, init_name));
    create_init_common_param_for_arrays(init_file, common);
    hpfc_fclose(init_file, init_name);
 
    ifdebug(1)
    {
        fprintf(stderr, "Result of HPFC for common %s\n", entity_name(common));
        fprintf(stderr, "-----------------\n");
 
        hpfc_print_file(parm_name);
        hpfc_print_file(init_name);
        hpfc_print_file(host_name);
        hpfc_print_file(node_name);
    }
 
    free(parm_name),
    free(init_name),
    free(host_name),
    free(node_name);
}

References create_init_common_param_for_arrays(), create_parameters_h(), db_get_current_workspace_directory(), entity_name, fprintf(), free(), full_name, HINC_SUFFIX, host_module, hpfc_fclose(), hpfc_fopen(), hpfc_print_common(), hpfc_print_file(), ifdebug, INIT_SUFFIX, load_new_host(), load_new_node(), module_local_name(), NINC_SUFFIX, node_module, PARM_SUFFIX, prefix, and src.

Referenced by compile_common().

Here is the call graph for this function:

Here is the caller graph for this function:

put_generated_resources_for_module()

void put_generated_resources_for_module	(	statement	,
		statement	,
		statement
	)

put_generated_resources_for_program()

void put_generated_resources_for_program

(

string

)

pvm_what_option_expression()

expression pvm_what_option_expression

(

entity

v

)

Definition at line 74 of file run-time.c.

{
    pips_assert("variable", entity_variable_p(v));
 
    return(MakeCharacterConstantExpression
               (strdup(pvm_what_options(entity_basic(v)))));
}

References entity_basic(), entity_variable_p, MakeCharacterConstantExpression(), pips_assert, pvm_what_options(), and strdup().

Referenced by st_call_send_or_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

pvm_what_options()

string pvm_what_options

(

basic

b

)

string pvm_what_options(b)

the pvm what option is given back as a string, fellowing the basic given.

Definition at line 86 of file run-time.c.

{
    switch (basic_tag(b))
    {
    case is_basic_int:
        switch (basic_int(b))
        {
        case 2: return(PVM_INTEGER2);
        case 4: return(PVM_INTEGER4);
        default:
            pips_internal_error("unexpected integer*%d", basic_int(b));
        }
    case is_basic_float:
        switch (basic_float(b))
        {
        case 4: return(PVM_REAL4);
        case 8: return(PVM_REAL8);
        default:
            pips_internal_error("unexpected real*%d", basic_float(b));
        }
    case is_basic_logical:
        switch (basic_logical(b))
        {
        case 2: return(PVM_INTEGER2);
        case 4: return(PVM_INTEGER4);
        default:
            pips_internal_error("unexpected logical*%d", basic_logical(b));
        }
    case is_basic_overloaded:
        pips_internal_error("overloaded not welcomed");
    case is_basic_complex:
        switch (basic_complex(b))
        {
        case  8: return(PVM_COMPLEX8);
        case 16: return(PVM_COMPLEX16);
        default:
            pips_internal_error("unexpected complex*%d", basic_complex(b));
        }
    case is_basic_string:
        return(PVM_STRING);
    default:
        pips_internal_error("unexpected basic tag");
    }
    return("ERROR");
}

References basic_complex, basic_float, basic_int, basic_logical, basic_tag, is_basic_complex, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_string, pips_internal_error, PVM_COMPLEX16, PVM_COMPLEX8, PVM_INTEGER2, PVM_INTEGER4, PVM_REAL4, PVM_REAL8, and PVM_STRING.

Referenced by hpfc_buffer_entity(), make_new_reduction_function(), make_packing_function(), make_reduction_function(), make_shift_subroutine(), and pvm_what_option_expression().

Here is the caller graph for this function:

ref_to_dist_array_p()

bool ref_to_dist_array_p

(

void *

obj

)

hpfc-util.c

hpfc-util.c

Fabien Coelho, May 1993. Predicates true if there is a reference to a distributed array within obj

??? not very intelligent, should use the regions, the problem is that I should normalize the code before the pips analysis...

Parameters

obj

bj

Definition at line 48 of file hpfc-util.c.

{
    list l = FindRefToDistArray(obj);
    bool b = (l!=NIL);
 
    gen_free_list(l); return(b);
}

References FindRefToDistArray(), gen_free_list(), and NIL.

Referenced by call_filter(), hpf_compile_call(), and test_atomization().

Here is the call graph for this function:

Here is the caller graph for this function:

references_aligned_p()

bool references_aligned_p	(	reference	r1,
		reference	r2
	)

of expression

both references must be aligned to the same template and be of the same arity.

Parameters

r1	1
r2	2

Definition at line 726 of file hpfc-util.c.

{
    entity e1 = reference_variable(r1),
           e2 = reference_variable(r2);
    list /* of expression */ le1 = reference_indices(r1),
                             le2 = reference_indices(r2);
    int dim1 = 1, dim2;
    entity index;
    align a1, a2;
 
    if (!array_distributed_p(e1) || !array_distributed_p(e2))
    {
        XDEBUG("not distributed"); return false;
    }
 
    a1 = load_hpf_alignment(e1);
    a2 = load_hpf_alignment(e2);
 
    /* both references must be aligned to the same template
     * and be of the same arity.
     */
    if (align_template(a1)!=align_template(a2))
    {
        XDEBUG("template is different"); return false;
    }
 
    if (gen_length(le1)!=gen_length(le2))
    {
        XDEBUG("arities are different"); return false;
    }
    
    MAP(EXPRESSION, ind, 
    {
        if (!expression_reference_p(ind))
            return false;
 
        index = reference_variable(syntax_reference(expression_syntax(ind)));
        dim2 = expression_number_for_index(index, le2);
 
        if (!alignments_compatible_p(e1, dim1, e2, dim2))
        {
            XDEBUG("alignments are incompatible"); return false;
        }
        
        dim1++;
    },
        le1);
 
    XDEBUG("aligned!"); return true;
}

References align_template, alignments_compatible_p(), array_distributed_p(), EXPRESSION, expression_number_for_index(), expression_reference_p(), expression_syntax, gen_length(), load_hpf_alignment(), MAP, reference_indices, reference_variable, syntax_reference, and XDEBUG.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

remapping_already_computed_p()

bool remapping_already_computed_p

(

renaming

x

)

list of already computed remappings...

exported interface

Definition at line 105 of file hpfc.c.

{
    entity src = renaming_old(x), trg = renaming_new(x);
 
    MAP(REMAPPING, r, 
    {
        renaming p = remapping_renaming(r);
        if (renaming_old(p)==src && renaming_new(p)==trg) 
            return true;
    },
        get_computed_remaps());
 
    return false;
}

References MAP, REMAPPING, remapping_renaming, renaming_new, renaming_old, src, and x.

Referenced by remapping_compile().

Here is the caller graph for this function:

remapping_compile()

void remapping_compile	(	statement	s,
		statement *	hsp,
		statement *	nsp
	)

void remapping_compile(s, hsp, nsp) statement s, *hsp, *nsp;

what: generates the remapping code for s. how: polyhedron technique. input: s, the statement. output: statements *hsp and *nsp, the host and SPMD node code. side effects: (none?) bugs or features: idem Node

of statements

nothing for host

comment at the end

dynamic liveness management if required

remapping codes (indirect thru include)

KILL => status update

comment at the beginning

block of remaps for the nodes

Parameters

hsp	initial statement in the source code
nsp	Host Statement Pointer

Definition at line 1302 of file remapping.c.

{
    statement tmp;
    list /* of statements */ l = NIL;
    
    debug_on("HPFC_REMAPPING_DEBUG_LEVEL");
    what_stat_debug(1, s);
 
    *hsp = make_empty_statement(); /* nothing for host */
 
    /* comment at the end
     */
    tmp = make_empty_statement();
    {
        string comment = strdup(concatenate("! end remappings\n", NULL));
        insert_comments_to_statement(tmp, comment);
        free(comment);
    }
    l = CONS(STATEMENT, tmp, l);
 
    /* dynamic liveness management if required
     */
    if (get_bool_property("HPFC_DYNAMIC_LIVENESS"))
    {
        l = CONS(STATEMENT, generate_dynamic_liveness_management(s), l);
    }
 
    /* remapping codes (indirect thru include)
     */
    MAP(RENAMING, r,
    {
        pips_debug(7, "remapping %s -> %s\n", entity_name(renaming_old(r)),
                   entity_name(renaming_new(r)));
        if (renaming_old(r)==renaming_new(r)) /* KILL => status update */
            l = CONS(STATEMENT, set_array_status_to_target(renaming_new(r)),
                     l);
        else 
        {
            if (!remapping_already_computed_p(r))
                generate_hpf_remapping_file(r);
            
            add_remapping_as_used(r);
            l = CONS(STATEMENT, generate_remapping_include(r), l);
        }
    },
        load_renamings(s));
 
    /* comment at the beginning
     */
    tmp = make_empty_statement();
    {
        string comment = strdup(concatenate("! begin remappings\n", NULL));
        insert_comments_to_statement(tmp, comment);
        free(comment);
    }
    l = CONS(STATEMENT, tmp, l);
 
    *nsp = make_block_statement(l); /* block of remaps for the nodes */
    DEBUG_STAT(8, "result", *nsp);
 
    debug_off();
}

References add_remapping_as_used(), comment(), concatenate(), CONS, debug_off, debug_on, DEBUG_STAT, entity_name, free(), generate_dynamic_liveness_management(), generate_hpf_remapping_file(), generate_remapping_include(), get_bool_property(), insert_comments_to_statement(), load_renamings(), make_block_statement(), make_empty_statement, MAP, NIL, pips_debug, remapping_already_computed_p(), RENAMING, renaming_new, renaming_old, set_array_status_to_target(), STATEMENT, strdup(), and what_stat_debug.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_variables_from_system()

void remove_variables_from_system	(	Psysteme *	ps,
		list *	plv
	)

Parameters

ps	s
plv	lv

Definition at line 345 of file io-compile.c.

{
    MAP(ENTITY, e,
    {
        pips_debug(8, "removing variable %s\n", entity_local_name(e));
        sc_projection_along_variable_ofl_ctrl(ps, (Variable) e, NO_OFL_CTRL);
    },
        *plv);
 
    gen_free_list(*plv), *plv=NIL;
}

References ENTITY, entity_local_name(), gen_free_list(), MAP, NIL, NO_OFL_CTRL, and pips_debug.

Referenced by clean_the_system().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_variables_if_possible()

void remove_variables_if_possible	(	Psysteme *	psyst,
		list *	plvars
	)

Parameters

psyst	syst
plvars	lvars

Definition at line 245 of file io-compile.c.

{
    Psysteme syst = *psyst;
    list kept = NIL;
 
    MAP(ENTITY, e, 
    {
        Variable var = (Variable) e;
        Value coeff = VALUE_MONE;
        
        (void) contrainte_var_min_coeff(sc_egalites(syst), var, &coeff, false);
        
        if (value_one_p(coeff))
        {
            Pvecteur v = vect_new(var, VALUE_ONE);
            bool exact = true;
            
            pips_debug(7, "removing variable %s\n", 
                       entity_local_name((entity) var));
            
            sc_projection_along_variables_with_test_ofl_ctrl
                (&syst, v, &exact, NO_OFL_CTRL);
 
            pips_assert("exact projection", exact);
            vect_rm(v);
        }
        else
            kept = CONS(ENTITY, (entity) var, kept);
    }, 
        *plvars);
    
    base_rm(sc_base(syst)), sc_base(syst) = BASE_NULLE, sc_creer_base(syst);
    
    *psyst = syst;
    gen_free_list(*plvars), *plvars=kept;
}

References BASE_NULLE, base_rm, CONS, contrainte_var_min_coeff(), ENTITY, entity_local_name(), gen_free_list(), MAP, NIL, NO_OFL_CTRL, pips_assert, pips_debug, sc_creer_base(), VALUE_MONE, VALUE_ONE, value_one_p, vect_new(), and vect_rm().

Referenced by clean_shared_io_system(), and clean_the_system().

Here is the call graph for this function:

Here is the caller graph for this function:

renamings_undefined_p()

bool renamings_undefined_p

(

void

)

replicated_p()

bool replicated_p

(

entity

e

)

replicated_p

check whether the distributed array e is replicated or not.

Definition at line 96 of file hpfc-util.c.

{
    int i, ntdim;
    align a;
    list la, ld;
    entity template;
    distribute d;
 
    pips_assert("distributed array", array_distributed_p(e));
 
    a = load_hpf_alignment(e);
    la = align_alignment(a);    
    template = align_template(a);
    d = load_hpf_distribution(template);
    ld = distribute_distribution(d);
    ntdim = NumberOfDimension(template);
 
    for(i=1; i<=ntdim; i++, POP(ld))
        if (ith_dim_replicated_p(template, i, la, DISTRIBUTION(CAR(ld))))
            return true;
 
    return false;
}

References align_alignment, align_template, array_distributed_p(), CAR, distribute_distribution, DISTRIBUTION, ith_dim_replicated_p(), load_hpf_alignment(), load_hpf_distribution(), NumberOfDimension(), pips_assert, and POP.

Referenced by generate_update_distributed_value_from_host(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), hpfc_broadcast_buffers(), if_different_pe_and_not_twin(), io_efficient_compile(), Overlap_Analysis(), st_receive_from(), st_send_to_computer_if_necessary(), and st_send_to_host_and_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_current_loops()

void reset_current_loops

(

void

)

Definition at line 377 of file compiler-util.c.

{
    gen_free_list(current_loop_list);
    current_loop_list=NIL;
}

References current_loop_list, gen_free_list(), and NIL.

Here is the call graph for this function:

reset_data_status()

void reset_data_status

(

void

)

Definition at line 320 of file declarations.c.

{
    reset_new_declaration();
    reset_hpf_alignment();
    reset_hpf_distribution();
    reset_hpf_object_lists();
}

References reset_hpf_alignment(), reset_hpf_distribution(), and reset_hpf_object_lists().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_dynamic_hpf()

void reset_dynamic_hpf

(

void

)

Referenced by reset_dynamic_status().

Here is the caller graph for this function:

reset_dynamic_status()

void reset_dynamic_status

(

void

)

reset_similar_mapping();

Definition at line 90 of file dynamic.c.

{
    reset_dynamic_hpf();
    reset_primary_entity();
    reset_renamings();
    reset_maybeuseful_mappings();
    /* reset_similar_mapping(); */
}

References reset_dynamic_hpf(), reset_maybeuseful_mappings(), reset_primary_entity(), and reset_renamings().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_entity_status()

void reset_entity_status

(

void

)

Definition at line 110 of file host_node_entities.c.

{
    reset_new_host();
    reset_old_host();
    reset_new_node();
    reset_old_node();
}

References reset_new_host(), reset_new_node(), reset_old_host(), and reset_old_node().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_hpf_alignment()

void reset_hpf_alignment

(

void

)

Referenced by reset_data_status().

Here is the caller graph for this function:

reset_hpf_distribution()

void reset_hpf_distribution

(

void

)

Referenced by reset_data_status().

Here is the caller graph for this function:

reset_hpf_number()

void reset_hpf_number

(

void

)

Referenced by reset_hpf_number_status().

Here is the caller graph for this function:

reset_hpf_number_status()

void reset_hpf_number_status

(

void

)

Definition at line 142 of file declarations.c.

{
    reset_hpf_number();
    init_currents();
}

References init_currents(), and reset_hpf_number().

Referenced by reset_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_hpf_object_lists()

void reset_hpf_object_lists

(

void

)

Definition at line 91 of file declarations.c.

{
    distributed_arrays = NIL,
    templates = NIL,
    processors = NIL;
}

References NIL.

Referenced by free_hpf_object_lists(), init_data_status(), and reset_data_status().

Here is the caller graph for this function:

reset_hpf_reductions()

void reset_hpf_reductions

(

void

)

Referenced by reset_hpfc_status().

Here is the caller graph for this function:

reset_hpfc_current_statement()

void reset_hpfc_current_statement

(

void

)

reset_maybeuseful_mappings()

void reset_maybeuseful_mappings

(

void

)

Referenced by reset_dynamic_status().

Here is the caller graph for this function:

reset_new_host()

void reset_new_host

(

void

)

Referenced by reset_entity_status().

Here is the caller graph for this function:

reset_new_node()

void reset_new_node

(

void

)

Referenced by reset_entity_status().

Here is the caller graph for this function:

reset_old_host()

void reset_old_host

(

void

)

Referenced by reset_entity_status().

Here is the caller graph for this function:

reset_old_node()

void reset_old_node

(

void

)

Referenced by reset_entity_status().

Here is the caller graph for this function:

reset_only_io_map()

void reset_only_io_map

(

void

)

reset_overlap_status()

void reset_overlap_status

(

void

)

Referenced by reset_hpfc_status().

Here is the caller graph for this function:

reset_primary_entity()

void reset_primary_entity

(

void

)

Referenced by reset_dynamic_status().

Here is the caller graph for this function:

reset_renamings()

void reset_renamings

(

void

)

Referenced by reset_dynamic_status().

Here is the caller graph for this function:

reset_similar_mapping()

void reset_similar_mapping

(

void

)

reset_the_dynamics()

void reset_the_dynamics

(

void

)

reset_update_common_map()

void reset_update_common_map

(

void

)

root_statement_remapping_inits()

statement root_statement_remapping_inits

(

statement

root

)

returns the initialization statement: must initialize the status and liveness of arrays

of statement

of entity

LIVENESS(...) = .TRUE. STATUS(...) = ...

LIVENESS(...) = .FALSE.

Parameters

root

oot

Definition at line 1265 of file remapping.c.

{
    list /* of statement */ ls = NIL;
    list /* of entity */ le =
        list_of_distributed_arrays_for_module(get_current_module_entity());
 
    /* LIVENESS(...) = .TRUE.
     * STATUS(...) = ...
     */
    MAP(RENAMING, r,
        ls = CONS(STATEMENT, update_runtime_for_remapping(renaming_new(r)),ls),
        load_renamings(root));
 
    /* LIVENESS(...) = .FALSE.
     */
    MAP(ENTITY, array,
        if (bound_dynamic_hpf_p(array) && primary_entity_p(array))
            ls = CONS(STATEMENT, generate_all_liveness(array, false), ls),
        le);
 
    gen_free_list(le), le = NIL;
    
    return make_block_statement(ls);
}

References array, bound_dynamic_hpf_p(), CONS, ENTITY, gen_free_list(), generate_all_liveness(), get_current_module_entity(), list_of_distributed_arrays_for_module(), load_renamings(), make_block_statement(), MAP, NIL, primary_entity_p, RENAMING, renaming_new, STATEMENT, and update_runtime_for_remapping().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_load_primary_entity()

entity safe_load_primary_entity

(

entity

e

)

HPFC module by Fabien COELHO.

This file provides functions used by directives.c to deal with dynamic mappings (re*). It includes keeping track of variables tagged as dynamic, and managing the static synonyms introduced to deal with them in HPFC. DYNAMIC MANAGEMENT

the synonyms of a given array are stored in a entities. What I intend as a synonym is a version of the array or template which is distributed or aligned in a different way. the renamings are associated to the remapping statements here.

• dynamic_hpf: keeps track of entities declared as dynamic.
• primary_entity: primary entity of an entity, when synonyms are introduced to handle remappings.
• renamings: remappings associated to a statement.
• maybeuseful_mappings: to be kept for a statement.
• similar_mapping: copies with similar mappings...

Definition at line 61 of file dynamic.c.

{
    if (!bound_dynamic_hpf_p(e))
        pips_user_error("%s is not dynamic\n", entity_local_name(e));
   
    return load_primary_entity(e);
}

References bound_dynamic_hpf_p(), entity_local_name(), load_primary_entity(), and pips_user_error.

Referenced by alive_arrays(), continue_propagation_p(), and propagate_synonym().

Here is the call graph for this function:

Here is the caller graph for this function:

same_primary_entity_p()

bool same_primary_entity_p	(	entity	e1,
		entity	e2
	)

Parameters

e1	1
e2	2

Definition at line 70 of file dynamic.c.

{
    if (bound_primary_entity_p(e1) && bound_primary_entity_p(e2))
        return load_primary_entity(e1)==load_primary_entity(e2);
    else
        return false;
}

References bound_primary_entity_p(), and load_primary_entity().

Referenced by simple_switch_old_to_new().

Here is the call graph for this function:

Here is the caller graph for this function:

set_array_as_distributed()

void set_array_as_distributed

(

entity

)

Referenced by array_as_template(), new_synonym_array(), and one_align_directive().

Here is the caller graph for this function:

set_current_loops()

void set_current_loops

(

statement

obj

)

Parameters

obj

bj

Definition at line 371 of file compiler-util.c.

{
    pips_assert("no current loop", current_loop_list==NIL);
    gen_recurse(obj, loop_domain, gen_true, set_current_loops_rewrite);
}

References current_loop_list, gen_recurse, gen_true(), loop_domain, NIL, pips_assert, and set_current_loops_rewrite().

Referenced by Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

set_data_status()

void set_data_status

(

data_status

s

)

Definition at line 328 of file declarations.c.

{
    set_new_declaration(data_status_newdeclmap(s));
    set_hpf_alignment(data_status_alignmap(s));
    set_hpf_distribution(data_status_distributemap(s));
    distributed_arrays = data_status_arrays(s);
    templates = data_status_templates(s);
    processors = data_status_processors(s);
}

References data_status_alignmap, data_status_arrays, data_status_distributemap, data_status_newdeclmap, data_status_processors, data_status_templates, set_hpf_alignment(), and set_hpf_distribution().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_dynamic_hpf()

void set_dynamic_hpf

(

entity_entities

)

Referenced by set_dynamic_status().

Here is the caller graph for this function:

set_dynamic_status()

void set_dynamic_status

(

dynamic_status

d

)

set_similar_mapping(...)

Definition at line 108 of file dynamic.c.

{
    set_dynamic_hpf(dynamic_status_dynamics(d));
    set_primary_entity(dynamic_status_primary(d));
    set_renamings(dynamic_status_renamings(d));
    set_maybeuseful_mappings(dynamic_status_tokeep(d));
    /* set_similar_mapping(...) */
}

References dynamic_status_dynamics, dynamic_status_primary, dynamic_status_renamings, dynamic_status_tokeep, set_dynamic_hpf(), set_maybeuseful_mappings(), set_primary_entity(), and set_renamings().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_entity_as_dynamic()

void set_entity_as_dynamic

(

entity

e

)

a new dynamic entity is stored.

HPF allows arrays and templates as dynamic. ??? could be asserted, but not here. should be checked afterward.

else the entity was already declared as dynamic...

Definition at line 130 of file dynamic.c.

{
    if (!bound_dynamic_hpf_p(e))
    {
        store_dynamic_hpf(e, make_entities(CONS(ENTITY, e, NIL)));
        store_primary_entity(e, e);
 
        store_similar_mapping(e, e);
    }
    /* else the entity was already declared as dynamic... */
}

References bound_dynamic_hpf_p(), CONS, ENTITY, make_entities(), NIL, store_dynamic_hpf(), store_primary_entity(), and store_similar_mapping().

Referenced by hpfc_translate_call_with_distributed_args(), and new_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

set_entity_status()

void set_entity_status

(

entity_status

s

)

Definition at line 102 of file host_node_entities.c.

{
    set_new_host(entity_status_new_host(s));
    set_new_node(entity_status_new_node(s));
    set_old_host(entity_status_old_host(s));
    set_old_node(entity_status_old_node(s));
}

References entity_status_new_host, entity_status_new_node, entity_status_old_host, entity_status_old_node, set_new_host(), set_new_node(), set_old_host(), and set_old_node().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_hpf_alignment()

void set_hpf_alignment

(

alignmap

)

Referenced by set_data_status().

Here is the caller graph for this function:

set_hpf_distribution()

void set_hpf_distribution

(

distributemap

)

Referenced by set_data_status().

Here is the caller graph for this function:

set_hpf_number()

void set_hpf_number

(

entity_int

)

Referenced by set_hpf_number_status().

Here is the caller graph for this function:

set_hpf_number_status()

void set_hpf_number_status

(

numbers_status

s

)

Definition at line 148 of file declarations.c.

{
    set_hpf_number(numbers_status_numbermap(s));
    current_array_index = numbers_status_arrays(s);
    current_template_index = numbers_status_templates(s);
    current_processors_index = numbers_status_processors(s);
}

References current_array_index, current_processors_index, current_template_index, numbers_status_arrays, numbers_status_numbermap, numbers_status_processors, numbers_status_templates, and set_hpf_number().

Referenced by load_hpfc_status().

Here is the call graph for this function:

Here is the caller graph for this function:

set_hpf_reductions()

void set_hpf_reductions

(

statement_entities

)

Referenced by load_hpfc_status().

Here is the caller graph for this function:

set_hpfc_current_statement()

void set_hpfc_current_statement

(

statement

)

Referenced by Overlap_Analysis().

Here is the caller graph for this function:

set_maybeuseful_mappings()

void set_maybeuseful_mappings

(

statement_entities

)

Referenced by set_dynamic_status().

Here is the caller graph for this function:

set_new_host()

void set_new_host

(

entitymap

)

Referenced by set_entity_status().

Here is the caller graph for this function:

set_new_node()

void set_new_node

(

entitymap

)

Referenced by set_entity_status().

Here is the caller graph for this function:

set_old_host()

void set_old_host

(

entitymap

)

Referenced by set_entity_status().

Here is the caller graph for this function:

set_old_node()

void set_old_node

(

entitymap

)

Referenced by set_entity_status().

Here is the caller graph for this function:

set_only_io_map()

void set_only_io_map

(

statement_mapping

)

Referenced by only_io_mapping_initialize().

Here is the caller graph for this function:

set_overlap()

void set_overlap	(	entity	ent,
		int	dim,
		int	side,
		int	width
	)

set the overlap value for entity ent, on dimension dim, dans side side to width, which must be a positive integer.

if necessary, the overlap is updates with the value width.

set the overlap value for entity ent, on dimension dim, dans side side to width, which must be a positive integer.

set the overlap value for entity ent, on dimension dim, dans side side to width, which must be a positive integer. if necessary, the overlap is updates with the value width.

upper

lower

upper

lower

Parameters

ent	nt
dim	im
side	ide
width	idth

Definition at line 713 of file declarations.c.

{
    overlap o;
    int current;
 
    pips_assert("valid dimension", dim>0);
 
    pips_debug(10, "%s:(DIM=%d) %s%d\n", 
               entity_name(ent), dim, side?"+":"-", width);
 
    if (!bound_overlap_status_p(ent)) create_overlaps(ent);
    o = OVERLAP(gen_nth(dim-1, load_overlap_status(ent)));
 
    if (side) /* upper */
    {
        current = overlap_upper(o);
        if (current<width) overlap_upper(o)=width;
    }
    else /* lower */
    {
        current = overlap_lower(o);
        if (current<width) overlap_lower(o)=width;
    }
}

References assert, bound_overlap_status_p(), create_overlaps(), current, entity_name, gen_nth(), load_overlap_status(), OVERLAP, overlap_lower, overlap_upper, pips_assert, and pips_debug.

Referenced by deal_with_similars(), message_manageable_p(), and update_overlaps_of().

Here is the call graph for this function:

Here is the caller graph for this function:

set_overlap_status()

void set_overlap_status

(

overlapsmap

)

Referenced by load_hpfc_status().

Here is the caller graph for this function:

set_primary_entity()

void set_primary_entity

(

entitymap

)

Referenced by set_dynamic_status().

Here is the caller graph for this function:

set_processor()

void set_processor

(

entity

)

Referenced by new_processor().

Here is the caller graph for this function:

set_renamings()

void set_renamings

(

statement_renamings

)

Referenced by set_dynamic_status().

Here is the caller graph for this function:

set_similar_mapping()

void set_similar_mapping

(

entitymap

)

set_similar_mappings_for_updates()

void set_similar_mappings_for_updates

(

void

)

??? for final update after compilation! hummm....

??? should not deal with the same array twice...

may be in another module

Definition at line 162 of file dynamic.c.

{
    /* ??? for final update after compilation! hummm....
     */
 
    MAP(ENTITY, array,
    {
        pips_debug(7, "considering array %s\n", entity_name(array));
 
        /* ??? should not deal with the same array twice... 
         */
        if (dynamic_entity_p(array) && 
            bound_similar_mapping_p(array) && 
            bound_new_node_p(array)) /* may be in another module */
        {
            entity n = load_new_node(array);
            entity s = load_similar_mapping(array);
            entity ns = load_new_node(s);
 
            pips_debug(7, "array %s\n", entity_name(array));
            
            if (!bound_new_node_p(n)) {
                store_new_node_variable(ns, n);
                store_new_node_variable(ns, array);
            }
        }
    },
        list_of_distributed_arrays());
}

References array, bound_new_node_p(), bound_similar_mapping_p(), dynamic_entity_p, ENTITY, entity_name, list_of_distributed_arrays(), load_new_node(), load_similar_mapping(), MAP, pips_debug, and store_new_node_variable().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

set_template()

void set_template

(

entity

)

Referenced by array_as_template(), new_synonym_template(), and new_template().

Here is the caller graph for this function:

set_the_dynamics()

void set_the_dynamics

(

list

)

set_update_common_map()

void set_update_common_map

(

entity_mapping

)

shift_system_to_prime_variables()

Psysteme shift_system_to_prime_variables

(

Psysteme

s

)

Definition at line 173 of file build-system.c.

{
    return sc_rename_variables(s, (bool (*)())bound_dummy_to_prime_p,
                               (Variable(*)()) load_dummy_to_prime);
}

References sc_rename_variables().

Referenced by generate_remapping_system(), and processor_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

similar_mapping_undefined_p()

bool similar_mapping_undefined_p

(

void

)

simple_statement()

statement simple_statement

(

statement

s

)

Definition at line 735 of file special_cases.c.

{
    ok = true;
    simple_found = (statement) NULL;
    make_current_stmt_stack();
 
    gen_multi_recurse
        (s,
         statement_domain,  current_stmt_filter, current_stmt_rewrite,
         test_domain,       not_simple,          gen_null,
         loop_domain,       not_simple,          gen_null,
         call_domain,       check_simple,        gen_null,
         expression_domain, gen_false,           gen_null,
         NULL);
 
    free_current_stmt_stack();
 
    return (ok && simple_found) ? simple_found : NULL;
}

References call_domain, check_simple(), expression_domain, gen_false(), gen_multi_recurse(), gen_null(), loop_domain, not_simple(), ok, simple_found, statement_domain, and test_domain.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_deducable_variables()

list simplify_deducable_variables	(	Psysteme	syst,
		list	vars,
		list *	pleftvars
	)

list simplify_deducable_variables(syst, vars, pleftvars) Psysteme syst; list vars, *pleftvars;

variables from entity list vars that can be rebuilt by the Psysteme syst are removed from it and stored as an expression list which is returned. The variables that are not removed are returned as another entity list, *pleftvars. of expression

Parameters

syst	yst
vars	ars
pleftvars	leftvars

Definition at line 562 of file io-compile.c.

{
    list result = NIL;
    *pleftvars = NIL;
 
    MAP(ENTITY, dummy,
    {
        Pcontrainte eq = CONTRAINTE_UNDEFINED;
        Value coeff = VALUE_ZERO;
        
         if (eq = eq_v_min_coeff(sc_egalites(syst), (Variable) dummy, &coeff),
             value_one_p(coeff))
         {
             result = 
                 CONS(EXPRESSION,
                      make_expression(make_syntax(is_syntax_reference,
                                                  make_reference(dummy, NIL)),
                                      make_normalized(is_normalized_linear,
                                                      vect_dup(eq->vecteur))), 
                      result);
 
             syst = sc_variable_substitution_with_eq_ofl_ctrl(syst, eq, 
                                                              (Variable) dummy,
                                                              FWD_OFL_CTRL);
         }
         else
         {
             *pleftvars = CONS(ENTITY, dummy, *pleftvars);
         }
     },
         vars);
 
    base_rm(sc_base(syst)), sc_base(syst) = BASE_NULLE, sc_creer_base(syst);
 
    return(result);
}

References BASE_NULLE, base_rm, CONS, CONTRAINTE_UNDEFINED, ENTITY, eq, EXPRESSION, FWD_OFL_CTRL, is_normalized_linear, is_syntax_reference, make_expression(), make_normalized(), make_reference(), make_syntax(), MAP, NIL, sc_creer_base(), value_one_p, VALUE_ZERO, vect_dup(), and Scontrainte::vecteur.

Referenced by extract_lattice(), hpf_remapping(), and put_variables_in_ordered_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_remapping_graph()

void simplify_remapping_graph

(

void

)

void simplify_remapping_graph()

what: simplifies the remapping graph. how: propagate unused reaching mappings to the next remappings, and remove unnecessary remappings. input: none. output: none. side effects: all is there!

• the remapping graph remappings are modified.
• some static structures are used.
• current module statement needed. bugs or features:
• special treatment of the current module statement to model the initial mapping at the entry of the module. The initial mapping may be modified by the algorithm if it is remapped before being used.
• ??? the convergence and correctness are to be proved.
• expected complexity: n vertices (small!), q nexts, m arrays, r remaps. assumes fast sets instead of lists, with O(1) tests/add/del... closure: O(n^2*vertex_operation) (if it is a simple propagation...) map: O(n*vertex_operation) C = n^2 q m r

of statements

Definition at line 1467 of file dynamic.c.

{
    list /* of statements */ ls = list_of_remapping_statements();
    statement root = get_current_module_statement();
    what_stat_debug(4, root);
 
    ifdebug(8) dump_remapping_graph("0", ls);
 
    gen_map((gen_iter_func_t)initialize_reaching_propagation, ls);
    gen_map((gen_iter_func_t)remove_not_remapped_leavings, ls);
    gen_map((gen_iter_func_t)initialize_maybeuseful_mappings, ls);
    gen_map((gen_iter_func_t)reinitialize_reaching_mappings, ls);
 
    ifdebug(4) dump_remapping_graph("1", ls);
 
    pips_debug(4, "used array propagation\n");
    gen_closure((gen_closure_func_t) propagate_used_arrays, ls);
 
    pips_debug(4, "may be useful mapping propagation\n");
    gen_closure((gen_closure_func_t) propagate_maybeuseful_mappings, ls);
 
    ifdebug(4) dump_remapping_graph("2", ls);
 
    if (bound_remapped_p(root)) remove_unused_remappings(root);
 
    gen_map((gen_iter_func_t)regenerate_renamings, ls);
 
    gen_free_list(ls);
}

References dump_remapping_graph(), gen_closure(), gen_free_list(), gen_map(), get_current_module_statement(), ifdebug, initialize_maybeuseful_mappings(), initialize_reaching_propagation(), list_of_remapping_statements(), pips_debug, propagate_maybeuseful_mappings(), propagate_used_arrays(), regenerate_renamings(), reinitialize_reaching_mappings(), remove_not_remapped_leavings(), remove_unused_remappings(), and what_stat_debug.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_lrange()

char* sprint_lrange	(	string	str,
		list	l
	)

Parameters

str

tr

Definition at line 217 of file message-utils.c.

{
    string s = str;
    bool firstrange = true;
 
    MAP(RANGE, r,
    {
        if (!firstrange)
        {
            sprintf(s, ", "); 
            s += strlen(s);
        }
        else
            firstrange = false;
 
        sprint_range(s, r);
        s += strlen(s);
    },
        l);
 
    return str;
}

References MAP, RANGE, and sprint_range().

Referenced by st_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_range()

char* sprint_range	(	string	str,
		range	r
	)

Parameters

str

tr

Definition at line 242 of file message-utils.c.

{
    int lo, up, in;
    bool
        blo = hpfc_integer_constant_expression_p(range_lower(r), &lo),
        bup = hpfc_integer_constant_expression_p(range_upper(r), &up),
        bin = hpfc_integer_constant_expression_p(range_increment(r), &in);
 
    if (blo && bup && bin)
    {
        if (in==1)
        {
            if (lo==up)
                sprintf(str, "%d", lo);
            else
                sprintf(str, "%d:%d", lo, up);
        }
        else
            sprintf(str, "%d:%d:%d", lo, up, in);
    }
    else
        sprintf(str, "X");
 
    return str+strlen(str);
}

References hpfc_integer_constant_expression_p(), range_increment, range_lower, and range_upper.

Referenced by sprint_lrange().

Here is the call graph for this function:

Here is the caller graph for this function:

st_call_send_or_receive()

statement st_call_send_or_receive	(	entity	f,
		reference	r
	)

Sends.

Definition at line 138 of file run-time.c.

{
    return
         hpfc_make_call_statement(f,
           CONS(EXPRESSION, pvm_what_option_expression(reference_variable(r)),
           CONS(EXPRESSION, reference_to_expression(r),
                NIL)));
}

References CONS, EXPRESSION, f(), hpfc_make_call_statement(), NIL, pvm_what_option_expression(), reference_to_expression(), and reference_variable.

Here is the call graph for this function:

st_compute_current_computer()

statement st_compute_current_computer

(

reference

ref

)

Computes.

Parameters

ref

ef

Definition at line 151 of file run-time.c.

{
    if (get_bool_property("HPFC_EXPAND_COMPUTE_COMPUTER"))
    {
        list linds = reference_indices(ref),
             largs = make_list_of_constant(0, 7-gen_length(linds));
        int narray = load_hpf_number(reference_variable(ref));
        
        largs = gen_nconc(CONS(EXPRESSION, int_to_expression(narray), 
                               NIL),
                          gen_nconc(lUpdateExpr(node_module, linds), largs));
        
        return hpfc_make_call_statement(hpfc_name_to_entity(CMP_COMPUTER), 
                                      largs);
    }
    else
        return hpfc_make_call_statement(hpfc_name_to_entity(CMP_COMPUTER),
                     CONS(EXPRESSION, reference_to_expression(ref),
                          NIL));
}

References CMP_COMPUTER, CONS, EXPRESSION, gen_length(), gen_nconc(), get_bool_property(), hpfc_make_call_statement(), hpfc_name_to_entity(), int_to_expression(), load_hpf_number(), lUpdateExpr(), make_list_of_constant(), NIL, node_module, ref, reference_indices, reference_to_expression(), and reference_variable.

Referenced by generate_c1_alpha(), and generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

st_compute_current_owners()

statement st_compute_current_owners

(

reference

ref

)

Parameters

ref

ef

Definition at line 173 of file run-time.c.

{
    if (get_bool_property("HPFC_EXPAND_COMPUTE_OWNER"))
    {
        list linds = reference_indices(ref),
             largs = make_list_of_constant(0, 7-gen_length(linds));
        int narray = load_hpf_number(reference_variable(ref));
        
        largs = gen_nconc(CONS(EXPRESSION, int_to_expression(narray), NIL),
                          gen_nconc(lUpdateExpr(node_module,  linds), largs));
        
        return hpfc_make_call_statement(hpfc_name_to_entity(CMP_OWNERS), 
                                      largs);
    }
    else
        return hpfc_make_call_statement(hpfc_name_to_entity(CMP_OWNERS),
                     CONS(EXPRESSION, reference_to_expression(ref),
                          NIL));
}

References CMP_OWNERS, CONS, EXPRESSION, gen_length(), gen_nconc(), get_bool_property(), hpfc_make_call_statement(), hpfc_name_to_entity(), int_to_expression(), load_hpf_number(), lUpdateExpr(), make_list_of_constant(), NIL, node_module, ref, reference_indices, reference_to_expression(), and reference_variable.

Referenced by generate_read_of_ref_for_all(), generate_read_of_ref_for_computer(), generate_update_distributed_value_from_host(), generate_update_values_on_computer_and_nodes(), and generate_update_values_on_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

st_compute_ith_local_index()

statement st_compute_ith_local_index	(	entity	array,
		int	i,
		expression	expr,
		syntax *	sp
	)

the returned expression is translated into variables of the node module.

the necessity is not checked, but it could be done, looking that the new declaration of the given array is smaller or not on the given dimension...

Parameters

array	rray
expr	xpr
sp	p

Definition at line 775 of file generate.c.

{
    /* the necessity is not checked, but it could be done,
     * looking that the new declaration of the given array
     * is smaller or not on the given dimension...
     */
 
    entity temp = make_new_scalar_variable(node_module,
                                           MakeBasic(is_basic_int));
    statement stat;
    AddEntityToCurrentModule(temp);
 
    (*sp)=make_syntax(is_syntax_reference, make_reference(temp, NIL));
 
    stat=instruction_to_statement
        (make_assign_instruction
         (reference_to_expression(make_reference(temp, NIL)),
          expr_compute_local_index(array,
                                   i,
                                   UpdateExpressionForModule(node_module,
                                                             expr))));
 
    return(stat);
}

References AddEntityToCurrentModule(), array, expr_compute_local_index(), instruction_to_statement(), is_basic_int, is_syntax_reference, make_assign_instruction(), make_new_scalar_variable(), make_reference(), make_syntax(), MakeBasic(), NIL, node_module, reference_to_expression(), and UpdateExpressionForModule().

Referenced by generate_compute_local_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

st_compute_neighbour()

statement st_compute_neighbour

(

int

d

)

call to the runtime support function HPFC_CMPNEIGHBOUR(d)

Definition at line 394 of file run-time.c.

{
    return hpfc_make_call_statement(hpfc_name_to_entity(CMP_NEIGHBOUR), 
                                  CONS(EXPRESSION, int_to_expression(d),
                                       NIL));
}

References CMP_NEIGHBOUR, CONS, EXPRESSION, hpfc_make_call_statement(), hpfc_name_to_entity(), int_to_expression(), and NIL.

Referenced by st_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

st_generate_packing()

statement st_generate_packing	(	entity	array,
		list	content,
		bool	bsend
	)

statement st_generate_packing_and_passing(array, content, bsend)

dimension bounds are refered to as parameters, since we do not know yet what is the lower and upper of each dimension...

larg content:

array, dim [lower, upper]*len, range [lower, upper, increment]*len

Parameters

array	rray
content	ontent
bsend	send

Definition at line 422 of file run-time.c.

{
    int len = gen_length(content);
    list larg = NIL;
 
    pips_assert("valid number of dimensions",
                len==NumberOfDimension(array) && (len<=4) && (len>=1));
 
    larg = array_lower_upper_bounds_list(array);
 
    MAP(RANGE, r,
     {
         larg = gen_nconc(larg,
                          CONS(EXPRESSION, range_lower(r),
                          CONS(EXPRESSION, range_upper(r),
                          CONS(EXPRESSION, range_increment(r),
                               NIL))));
     },
         content);
 
    larg = CONS(EXPRESSION, entity_to_expression(array),
                larg);
    
    /* larg content:
     *
     * array, dim [lower, upper]*len, range [lower, upper, increment]*len
     */
 
    return hpfc_make_call_statement
           (make_packing_function(len, bsend, entity_basic(array), 1+5*len),
            larg);
 
}

References array, array_lower_upper_bounds_list(), CONS, entity_basic(), entity_to_expression(), EXPRESSION, gen_length(), gen_nconc(), hpfc_make_call_statement(), make_packing_function(), MAP, NIL, NumberOfDimension(), pips_assert, RANGE, range_increment, range_lower, and range_upper.

Referenced by st_one_message().

Here is the call graph for this function:

Here is the caller graph for this function:

st_get_value_for_all()

statement st_get_value_for_all	(	reference	ref,
		reference	goal
	)

Parameters

ref	ef
goal	oal

Definition at line 842 of file generate.c.

{
    return
        st_make_nice_test(condition_ownerp(),
         CONS(STATEMENT, st_get_value_locally_and_send(ref,goal), NIL),
         CONS(STATEMENT, st_receive_from(ref,goal), NIL));
}

References condition_ownerp, CONS, NIL, ref, st_get_value_locally_and_send(), st_make_nice_test(), st_receive_from(), and STATEMENT.

Referenced by generate_read_of_ref_for_all().

Here is the call graph for this function:

Here is the caller graph for this function:

st_get_value_for_computer()

statement st_get_value_for_computer	(	reference	ref,
		reference	goal
	)

Parameters

ref	ef
goal	oal

Definition at line 850 of file generate.c.

{
    list ltrue=NIL, lfalse=NIL;
    generate_get_value_locally(ref,goal,&ltrue);
    lfalse=CONS(STATEMENT,st_receive_from_sender(goal),NIL);
    return st_make_nice_test(condition_ownerp(),ltrue,lfalse);
}

References condition_ownerp, CONS, generate_get_value_locally(), NIL, ref, st_make_nice_test(), st_receive_from_sender, and STATEMENT.

Referenced by generate_read_of_ref_for_computer().

Here is the call graph for this function:

Here is the caller graph for this function:

st_get_value_locally_and_send()

statement st_get_value_locally_and_send	(	reference	ref,
		reference	goal
	)

Parameters

ref	ef
goal	oal

Definition at line 760 of file generate.c.

{
    list ls=NIL;
 
    generate_get_value_locally(ref,goal,&ls);
    ls=gen_nconc(ls, CONS(STATEMENT, st_send_to_host_and_nodes(ref, goal),
                          NIL));
 
    return(make_block_statement(ls));
}

References CONS, gen_nconc(), generate_get_value_locally(), make_block_statement(), NIL, ref, st_send_to_host_and_nodes(), and STATEMENT.

Referenced by st_get_value_for_all().

Here is the call graph for this function:

Here is the caller graph for this function:

st_receive_from()

statement st_receive_from	(	reference	ref,
		reference	goal
	)

if ref is replicated: goal = Receive_From_Sender()

if ref is not replicated goal = Receive_Multi_Cast_From_Sender()

Parameters

ref	ef
goal	oal

Definition at line 865 of file generate.c.

{
    if (replicated_p(reference_variable(ref)))
        return st_receive_from_sender(goal);
    else
        return st_receive_mcast_from_sender(goal);
}

References ref, reference_variable, replicated_p(), st_receive_from_sender, and st_receive_mcast_from_sender.

Referenced by generate_read_of_ref_for_all(), and st_get_value_for_all().

Here is the call graph for this function:

Here is the caller graph for this function:

st_send_to_computer_if_necessary()

statement st_send_to_computer_if_necessary

(

reference

ref

)

Parameters

ref

ef

Definition at line 817 of file generate.c.

{
    entity
        array = reference_variable(ref),
        newarray = load_new_node(array);
    expression
        condition=((replicated_p(array))?
                   (MakeBinaryCall
                    (entity_intrinsic(AND_OPERATOR_NAME),
                     condition_senderp(),
                     condition_not_computer_in_owners())):
                   (condition_senderp()));
    list lstat = NIL, lnewinds = NIL;
 
    generate_compute_local_indices(ref, &lstat, &lnewinds);
 
    return
      st_make_nice_test(condition,
        gen_nconc(lstat,
          CONS(STATEMENT,
               st_send_to_computer(make_reference(newarray, lnewinds)),
               NIL)),
                        NIL);
}

References AND_OPERATOR_NAME, array, condition_not_computer_in_owners, condition_senderp, CONS, entity_intrinsic(), gen_nconc(), generate_compute_local_indices(), load_new_node(), make_reference(), MakeBinaryCall(), NIL, ref, reference_variable, replicated_p(), st_make_nice_test(), st_send_to_computer, and STATEMENT.

Referenced by generate_read_of_ref_for_computer().

Here is the call graph for this function:

Here is the caller graph for this function:

st_send_to_host_and_nodes()

statement st_send_to_host_and_nodes	(	reference	ref,
		reference	val
	)

Parameters

ref	ef
val	al

Definition at line 804 of file generate.c.

{
    if(replicated_p(reference_variable(ref)))
        return(st_make_nice_test(condition_senderp(),
                                 CONS(STATEMENT,
                                      st_send_to_host_and_not_owners(val),
                                      NIL),
                                 NIL));
    else
        return st_send_to_host_and_all_nodes(val);
}

References condition_senderp, CONS, NIL, ref, reference_variable, replicated_p(), st_make_nice_test(), st_send_to_host_and_all_nodes, st_send_to_host_and_not_owners, and STATEMENT.

Referenced by st_get_value_locally_and_send().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_only_io_undefined_p()

bool statement_only_io_undefined_p

(

statement

)

statement_structural_cleaning()

void statement_structural_cleaning

(

statement

s

)

Definition at line 847 of file hpfc-util.c.

{
    make_current_stmt_stack();
 
    gen_multi_recurse(s,
        statement_domain, current_stmt_filter, current_stmt_rewrite,
        test_domain,      gen_true,            test_rewrite,
        loop_domain,      gen_true,            loop_rewrite,
                      NULL);  
  
    free_current_stmt_stack();
}

References gen_multi_recurse(), gen_true(), loop_domain, loop_rewrite(), statement_domain, test_domain, and test_rewrite().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

store_dynamic_hpf()

void store_dynamic_hpf	(	entity	,
		entities
	)

Referenced by add_dynamic_synonym(), and set_entity_as_dynamic().

Here is the caller graph for this function:

store_entity_update_common()

void store_entity_update_common	(	entity	,
		entity
	)

Referenced by NormalizeCommonVariables().

Here is the caller graph for this function:

store_hpf_alignment()

void store_hpf_alignment	(	entity	,
		align
	)

Referenced by array_as_template(), new_synonym_array(), and one_align_directive().

Here is the caller graph for this function:

store_hpf_distribution()

void store_hpf_distribution	(	entity	,
		distribute
	)

Referenced by new_synonym_template(), and one_distribute_directive().

Here is the caller graph for this function:

store_hpf_number()

void store_hpf_number	(	entity	,
		intptr_t
	)

Referenced by GiveToHpfObjectsTheirNumber().

Here is the caller graph for this function:

store_hpf_reductions()

void store_hpf_reductions	(	statement	,
		entities
	)

Referenced by handle_reduction_directive().

Here is the caller graph for this function:

store_maybeuseful_mappings()

void store_maybeuseful_mappings	(	statement	,
		entities
	)

Referenced by initialize_maybeuseful_mappings().

Here is the caller graph for this function:

store_new_host()

void store_new_host	(	entity	,
		entity
	)

Referenced by AddEntityToHostAndNodeModules().

Here is the caller graph for this function:

store_new_host_node_variable()

void store_new_host_node_variable	(	entity	neh,
		entity	nen,
		entity	old
	)

Parameters

neh	eh
nen	en
old	ld

Definition at line 73 of file host_node_entities.c.

{
    store_new_host_variable(neh, old);
    store_new_host_variable(neh, nen);
    store_new_node_variable(nen, old);
    store_new_node_variable(nen, neh);
}

References store_new_host_variable(), and store_new_node_variable().

Referenced by make_host_and_node_modules().

Here is the call graph for this function:

Here is the caller graph for this function:

store_new_host_variable()

void store_new_host_variable	(	entity	new,
		entity	old
	)

Parameters

new	ew
old	ld

Definition at line 64 of file host_node_entities.c.

{
    pips_assert("defined", !entity_undefined_p(new)&&!entity_undefined_p(old));
 
    store_or_update_new_host(old, new);
    store_or_update_old_host(new, old);
}

References entity_undefined_p, pips_assert, store_or_update_new_host(), and store_or_update_old_host().

Referenced by add_declaration_to_host_and_link(), AddCommonToHostAndNodeModules(), AddEntityToHostAndNodeModules(), automatic_translation(), hpfc_compile(), make_host_and_node_modules(), and store_new_host_node_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

store_new_node()

void store_new_node	(	entity	,
		entity
	)

Referenced by AddEntityToHostAndNodeModules().

Here is the caller graph for this function:

store_new_node_variable()

void store_new_node_variable	(	entity	new,
		entity	old
	)

Parameters

new	ew
old	ld

Definition at line 55 of file host_node_entities.c.

{
    pips_assert("defined", !entity_undefined_p(new)&&!entity_undefined_p(old));
 
    store_or_update_new_node(old, new);
    store_or_update_old_node(new, old);
}

References entity_undefined_p, pips_assert, store_or_update_new_node(), and store_or_update_old_node().

Referenced by AddCommonToHostAndNodeModules(), AddEntityToHostAndNodeModules(), automatic_translation(), hpfc_compile(), make_host_and_node_modules(), set_similar_mappings_for_updates(), and store_new_host_node_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

store_old_host()

void store_old_host	(	entity	,
		entity
	)

store_old_node()

void store_old_node	(	entity	,
		entity
	)

store_or_update_dynamic_hpf()

void store_or_update_dynamic_hpf	(	entity	,
		entities
	)

store_or_update_hpf_alignment()

void store_or_update_hpf_alignment	(	entity	,
		align
	)

store_or_update_hpf_distribution()

void store_or_update_hpf_distribution	(	entity	,
		distribute
	)

store_or_update_hpf_number()

void store_or_update_hpf_number	(	entity	,
		intptr_t
	)

store_or_update_hpf_reductions()

void store_or_update_hpf_reductions	(	statement	,
		entities
	)

store_or_update_maybeuseful_mappings()

void store_or_update_maybeuseful_mappings	(	statement	,
		entities
	)

store_or_update_new_host()

void store_or_update_new_host	(	entity	,
		entity
	)

Referenced by store_new_host_variable().

Here is the caller graph for this function:

store_or_update_new_node()

void store_or_update_new_node	(	entity	,
		entity
	)

Referenced by store_new_node_variable().

Here is the caller graph for this function:

store_or_update_old_host()

void store_or_update_old_host	(	entity	,
		entity
	)

Referenced by store_new_host_variable().

Here is the caller graph for this function:

store_or_update_old_node()

void store_or_update_old_node	(	entity	,
		entity
	)

Referenced by store_new_node_variable().

Here is the caller graph for this function:

store_or_update_overlap_status()

void store_or_update_overlap_status	(	entity	,
		list
	)

store_or_update_primary_entity()

void store_or_update_primary_entity	(	entity	,
		entity
	)

store_or_update_renamings()

void store_or_update_renamings	(	statement	,
		list
	)

store_or_update_similar_mapping()

void store_or_update_similar_mapping	(	entity	,
		entity
	)

store_overlap_status()

void store_overlap_status	(	entity	,
		list
	)

Referenced by create_overlaps().

Here is the caller graph for this function:

store_primary_entity()

void store_primary_entity	(	entity	,
		entity
	)

Referenced by add_dynamic_synonym(), and set_entity_as_dynamic().

Here is the caller graph for this function:

store_renamings()

void store_renamings	(	statement	,
		list
	)

Referenced by handle_align_and_realign_directive(), handle_distribute_and_redistribute_directive(), handle_hpf_directives(), and handle_prescriptive_directive().

Here is the caller graph for this function:

store_similar_mapping()

void store_similar_mapping	(	entity	,
		entity
	)

Referenced by check_for_similarity(), and set_entity_as_dynamic().

Here is the caller graph for this function:

store_statement_only_io()

void store_statement_only_io	(	statement	,
		bool
	)

subarray_shift_p()

bool subarray_shift_p	(	statement	s,
		entity *	pe,
		list *	plvect
	)

Parameters

pe	e
plvect	lvect

Definition at line 530 of file special_cases.c.

{
    array = entity_undefined;
    subarray_shift_ok = true;
    lvect = NIL;
    current_regions = load_statement_local_regions(s);
 
    DEBUG_STAT(8, "considering statement", s);
 
    gen_multi_recurse(s,
                      call_domain, call_filter, gen_null,
                      loop_domain, loop_filter, gen_null,
                      test_domain, cannot_be_a_shift, gen_null,
                      expression_domain, gen_false, gen_null,
                      NULL);
 
    subarray_shift_ok &= !entity_undefined_p(array) &&
        rectangular_must_region_p(array, s);
 
    if (subarray_shift_ok)
        *pe = array,
        *plvect = lvect;
    else
        free_vector_list(lvect), lvect = NIL;
    current_regions = NIL;
 
    pips_debug(8, "returning %s\n", subarray_shift_ok? "TRUE": "FALSE");
    return subarray_shift_ok;
}

References array, call_domain, call_filter(), cannot_be_a_shift(), current_regions, DEBUG_STAT, entity_undefined, entity_undefined_p, expression_domain, free_vector_list(), gen_false(), gen_multi_recurse(), gen_null(), load_statement_local_regions(), loop_domain, loop_filter(), lvect, NIL, pips_debug, rectangular_must_region_p(), subarray_shift_ok, and test_domain.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

template_cell_local_mapping()

int template_cell_local_mapping	(	entity	array,
		int	dim,
		int	tc
	)

int template_cell_local_mapping(array, dim, tc)

??? should check that it is indeed block distributed ! or should implement all the formulas...

Parameters

array	rray
dim	im
tc	c

Definition at line 532 of file hpfc-util.c.

{
    alignment a = FindArrayDimAlignmentOfArray(array, dim);
    int p, tmin, n = DistributionParameterOfArrayDim(array, dim, &p);
    dimension d = FindIthDimension(array_to_template(array), 
                                   alignment_templatedim(a));
 
    tmin = HpfcExpressionToInt(dimension_lower(d));
 
    return (tc-tmin)%n+1;
}

References alignment_templatedim, array, array_to_template, dimension_lower, DistributionParameterOfArrayDim(), FindArrayDimAlignmentOfArray, FindIthDimension(), HpfcExpressionToInt(), and tc.

Referenced by generate_one_message(), global_array_cell_to_local_array_cell(), and update_indices_for_local_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

template_dimension_of_array_dimension()

int template_dimension_of_array_dimension	(	entity	array,
		int	dim
	)

Parameters

array	rray
dim	im

Definition at line 448 of file hpfc-util.c.

{
    align a;
    alignment al;
 
    a = load_hpf_alignment(array);
    al = FindAlignmentOfDim(align_alignment(a), dim);
    
    return (al==alignment_undefined) ? -1 : alignment_templatedim(al);
}

References align_alignment, alignment_templatedim, alignment_undefined, array, FindAlignmentOfDim(), and load_hpf_alignment().

Referenced by aligned_p(), get_alignment(), and message_manageable_p().

Here is the call graph for this function:

Here is the caller graph for this function:

template_ranges_to_processors_ranges()

list template_ranges_to_processors_ranges	(	entity	template,
		list	lrt
	)

??? another increment could be computed?

Parameters

template	emplate
lrt	rt

Definition at line 498 of file message-utils.c.

{
    distribute d = load_hpf_distribution(template);
    entity proc = distribute_processors(d);
    list ld = distribute_distribution(d), lrp = NIL;
    int i = 1;
 
    for (i=1 ; i<=NumberOfDimension(proc) ; i++)
    {
        int tdim = 0;
        distribution di = FindDistributionOfProcessorDim(ld, i, &tdim);
        style s = distribution_style(di);
        range rg = RANGE(gen_nth(tdim-1, lrt));
        int p  = 0,
            tl = HpfcExpressionToInt(range_lower(rg)),
            tu = HpfcExpressionToInt(range_upper(rg)),
            n  = HpfcExpressionToInt(distribution_parameter(di));
 
        switch (style_tag(s))
        {
        case is_style_block:
        {
            expression
              pl = int_to_expression(processor_number(template, tdim, tl, &p)),
              pu = int_to_expression(processor_number(template, tdim, tu, &p));
 
            /* ??? another increment could be computed?
             */
            lrp = gen_nconc(lrp,
                            CONS(RANGE,
                                 make_range(pl, pu, int_to_expression(1)),
                                 NIL));
            break;
        }
        case is_style_cyclic:
        {
            dimension dp = FindIthDimension(proc, i);
            int sz = dimension_size(dp);
            expression
              pl = int_to_expression(processor_number(template, tdim, tl, &p)),
              pu = int_to_expression(processor_number(template, tdim, tu, &p));
 
            if (((tu-tl)>n*sz) || (pl>pu) || ((pl==pu) && ((tu-tl)>n)))
                lrp = gen_nconc(lrp,
                            CONS(RANGE,
                                 make_range(dimension_lower(dp),
                                            dimension_upper(dp),
                                            int_to_expression(1)),
                                 NIL));
            else
                lrp = gen_nconc(lrp,
                                CONS(RANGE,
                                     make_range(pl, pu,
                                                int_to_expression(1)),
                                     NIL));
            
            break;
        }
        case is_style_none:
            pips_internal_error("unexpected none style distribution");
            break;
        default:
            pips_internal_error("unexpected style tag (%d)",
                       style_tag(s));
        }
    }
    return(lrp);
}

References CONS, dimension_lower, dimension_size(), dimension_upper, distribute_distribution, distribute_processors, distribution_parameter, distribution_style, FindDistributionOfProcessorDim(), FindIthDimension(), gen_nconc(), gen_nth(), HpfcExpressionToInt(), int_to_expression(), is_style_block, is_style_cyclic, is_style_none, load_hpf_distribution(), make_range(), NIL, NumberOfDimension(), pips_internal_error, pl, processor_number(), RANGE, range_lower, range_upper, and style_tag.

Referenced by loop_nest_guard(), and one_message_guards_and_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

template_synonym_distributed_as()

entity template_synonym_distributed_as	(	entity	temp,
		distribute	d
	)

what: finds or creates a new entity distributed as needed.

input: an template (which must be dynamic) and a distribute output: returns a template distributed as specified by d side effects:

• creates a new entity if necessary.
• this entity is stored as a synonym of array, and tagged as dynamic.
• the distribute is freed if not used.

the one found is returned

else no compatible template does exist, so one must be created

Parameters

temp

emp

Definition at line 491 of file dynamic.c.

{
    MAP(ENTITY, t,
    {
        if (same_distribute_p(load_hpf_distribution(t), d))
        {
            free_distribute(d);
            return t;    /* the one found is returned */
        }
    },
        entities_list(load_dynamic_hpf(temp)));
 
    /*  else no compatible template does exist, so one must be created
     */
    return new_synonym_template(temp, d);
}

References entities_list, ENTITY, free_distribute(), load_dynamic_hpf(), load_hpf_distribution(), MAP, new_synonym_template(), and same_distribute_p().

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

the_dynamics_undefined_p()

bool the_dynamics_undefined_p

(

void

)

end of it

cproto-generated files directives.c

the_index_of_vect()

Pvecteur the_index_of_vect

(

Pvecteur

v0

)

message-utils.c

message-utils.c

Fabien Coelho, August 1993 returns the index of an affine vector

Parameters

v0

0

Definition at line 37 of file message-utils.c.

{
    Pvecteur v1 = vect_del_var(v0, TCST);
 
    vect_erase_var(&v1, DELTAV);
    vect_erase_var(&v1, TEMPLATEV);
    vect_erase_var(&v1, TSHIFTV);
 
    assert(vect_size(v1)==1);
 
    return v1;
}

References assert, DELTAV, TCST, TEMPLATEV, TSHIFTV, vect_del_var(), vect_erase_var(), and vect_size().

Referenced by generate_one_message(), and update_indices_for_local_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

type_variable_dup()

type type_variable_dup

(

type

t

)

local-ri-util.c

!!! means sharing

Definition at line 30 of file local-ri-util.c.

{
    if(type_variable_p(t))
    {
        variable v = type_variable(t);
 
        return MakeTypeVariable(variable_basic(v),
                                ldimensions_dup(variable_dimensions(v)));
    }
    else
        return t; /* !!! means sharing */
}

References ldimensions_dup(), MakeTypeVariable(), type_variable, type_variable_p, variable_basic, and variable_dimensions.

Here is the call graph for this function:

update_common_map_undefined_p()

bool update_common_map_undefined_p

(

void

)

update_common_references_in_obj()

void update_common_references_in_obj

(

void *

obj

)

Parameters

obj

bj

Definition at line 911 of file compile.c.

{
    gen_multi_recurse(obj,
                      loop_domain, gen_true, update_loop_rewrite,
                      reference_domain, gen_true, update_common_rewrite,
                      NULL);
 
    ifdebug(8) debug_print_referenced_entities(obj);
}

References debug_print_referenced_entities(), gen_multi_recurse(), gen_true(), ifdebug, loop_domain, reference_domain, update_common_rewrite(), and update_loop_rewrite().

Referenced by NormalizeCommonVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

update_common_references_in_regions()

void update_common_references_in_regions

(

void

)

Definition at line 921 of file compile.c.

{
 
    STATEMENT_EFFECTS_MAP(stat, effs,
         {
             list lef = effects_effects(effs);
 
             pips_debug(3, "statement %p (%zu effects)\n",
                        stat, gen_length((list) lef));
 
             // FI: Let's hope the rw effects do not have to be
             // filtered to keep only the store effects...
             MAP(EFFECT, e, update_common_rewrite(effect_any_reference(e)),
                 (list) lef);
         },
             get_rw_effects());
}

References EFFECT, effect_any_reference, effects_effects, gen_length(), get_rw_effects(), MAP, pips_debug, STATEMENT_EFFECTS_MAP, and update_common_rewrite().

Here is the call graph for this function:

update_control_lists()

void update_control_lists	(	control	c,
		control_mapping	map
	)

compiler-util.c

compiler-util.c

Fabien Coelho, May 1993

Parameters

map

ap

Definition at line 36 of file compiler-util.c.

{
    control cprime = (control) GET_CONTROL_MAPPING(map, c);
 
    pips_assert("empty lists for cprime",
                control_predecessors(cprime)==NIL &&
                control_successors(cprime)==NIL);
 
    control_predecessors(cprime) = 
        updated_control_list(control_predecessors(c), map);
    control_successors(cprime) = 
        updated_control_list(control_successors(c), map);
}

References control_predecessors, control_successors, GET_CONTROL_MAPPING, NIL, pips_assert, and updated_control_list().

Referenced by hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

update_dynamic_hpf()

void update_dynamic_hpf	(	entity	,
		entities
	)

update_entity_update_common()

void update_entity_update_common	(	entity	,
		entity
	)

update_hpf_alignment()

void update_hpf_alignment	(	entity	,
		align
	)

update_hpf_distribution()

void update_hpf_distribution	(	entity	,
		distribute
	)

update_hpf_number()

void update_hpf_number	(	entity	,
		intptr_t
	)

update_hpf_reductions()

void update_hpf_reductions	(	statement	,
		entities
	)

update_list_for_module()

void update_list_for_module	(	list	l,
		entity	module
	)

Parameters

module

odule

Definition at line 215 of file host_node_entities.c.

{
    MAPL(cx, update_object_for_module(CHUNK(CAR(cx)), module), l);
}

References CAR, CHUNK, MAPL, module, and update_object_for_module().

Referenced by lUpdateExpr(), and lUpdateExpr_but_distributed().

Here is the call graph for this function:

Here is the caller graph for this function:

update_maybeuseful_mappings()

void update_maybeuseful_mappings	(	statement	,
		entities
	)

update_new_host()

void update_new_host	(	entity	,
		entity
	)

update_new_node()

void update_new_node	(	entity	,
		entity
	)

update_object_for_module()

void update_object_for_module	(	void *	obj,
		entity	module
	)

push the current functions

pop the initial functions

Parameters

obj	bj
module	odule

Definition at line 180 of file host_node_entities.c.

{
    bool (*saved_bound)(entity);
    entity (*saved_load)(entity);
 
    pips_debug(8, "updating (%s) %p\n", gen_domain_name(gen_type(obj)), obj);
 
    saved_bound = bound_p, saved_load = load; /* push the current functions */
 
    if (module==host_module)
    {
        pips_debug(8, "for host\n");
        bound_p = bound_new_host_p;
        load = load_new_host;
    }
    else
    {
        pips_debug(8, "for node\n");
        bound_p = bound_new_node_p;
        load = load_new_node;
    }
 
    gen_multi_recurse
        (obj, 
         reference_domain, gen_true, update_reference_for_module_rewrite,
         loop_domain, gen_true, update_loop_for_module_rewrite,
         call_domain, gen_true, update_call_for_module_rewrite,
         code_domain, gen_true, update_code_for_module_rewrite,
         NULL);
 
    bound_p = saved_bound, load = saved_load; /* pop the initial functions */
}

References bound_new_host_p(), bound_new_node_p(), bound_p, call_domain, code_domain, gen_domain_name(), gen_multi_recurse(), gen_true(), gen_type(), host_module, load, load_new_host(), load_new_node(), loop_domain, module, pips_debug, reference_domain, update_call_for_module_rewrite(), update_code_for_module_rewrite(), update_loop_for_module_rewrite(), and update_reference_for_module_rewrite().

Referenced by compile_module(), generate_hpf_remapping_file(), hpf_compile_call(), update_list_for_module(), UpdateExpressionForModule(), and UpdateStatementForModule().

Here is the call graph for this function:

Here is the caller graph for this function:

update_old_host()

void update_old_host	(	entity	,
		entity
	)

update_old_node()

void update_old_node	(	entity	,
		entity
	)

update_overlap_status()

void update_overlap_status	(	entity	,
		list
	)

update_overlaps_in_caller()

void update_overlaps_in_caller	(	entity	fun,
		list	le
	)

the overlaps of the actual parameters are updated according to the formal requirements.

Parameters

fun	un
le	e

Definition at line 864 of file declarations.c.

{
    int len = gen_length(le), i;
    for (i=1; i<=len; i++, POP(le))
    {
        entity v = find_ith_parameter(fun, i);
        if (array_distributed_p(v))
        {
            expression e = EXPRESSION(CAR(le));
            entity u = expression_to_entity(e), nu;
            pips_assert("bounded to a new var", bound_new_node_p(u));
            nu = load_new_node(u);
            pips_debug(5, "call to %s, %s (%s) -> %s\n", 
                       entity_name(fun), entity_name(u), 
                       entity_name(nu), entity_name(v));
            update_overlaps_of(u, v);
        }
 
    }
}

References array_distributed_p(), bound_new_node_p(), CAR, entity_name, EXPRESSION, expression_to_entity(), find_ith_parameter(), gen_length(), load_new_node(), pips_assert, pips_debug, POP, and update_overlaps_of().

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

update_primary_entity()

void update_primary_entity	(	entity	,
		entity
	)

update_renamings()

void update_renamings	(	statement	,
		list
	)

Referenced by initial_alignment(), one_align_directive(), one_distribute_directive(), and regenerate_renamings().

Here is the caller graph for this function:

update_similar_mapping()

void update_similar_mapping	(	entity	,
		entity
	)

update_statement_only_io()

void update_statement_only_io	(	statement	,
		bool
	)

updated_control_list()

list updated_control_list	(	list	lc,
		control_mapping	map
	)

Parameters

lc	c
map	ap

Definition at line 52 of file compiler-util.c.

{
    list lc_result = NIL;
    control new_c = control_undefined;
 
    MAP(CONTROL, current,
     {
         new_c = (control) GET_CONTROL_MAPPING(map, current);
 
         pips_assert("defined",
                     !control_undefined_p(current) ||
                     !control_undefined_p(new_c));
 
         lc_result = CONS(CONTROL, new_c, lc_result);
     },
         lc);
 
    return(gen_nreverse(lc_result));
}

References CONS, CONTROL, control_undefined, control_undefined_p, current, gen_nreverse(), GET_CONTROL_MAPPING, MAP, NIL, and pips_assert.

Referenced by update_control_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateExpressionForModule()

expression UpdateExpressionForModule	(	entity	module,
		expression	ex
	)

this function creates a new expression using the mapping of old to new variables map.

some of the structures generated may be shared...

Parameters

module	odule
ex	x

Definition at line 225 of file host_node_entities.c.

{
    expression new = copy_expression(ex);
    update_object_for_module(new, module);
    return(new);
}

References copy_expression(), module, and update_object_for_module().

Referenced by generate_c1_alpha(), generate_compute_local_indices(), hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), hpf_compile_test(), and st_compute_ith_local_index().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateStatementForModule()

statement UpdateStatementForModule	(	entity	module,
		statement	stat
	)

Parameters

module	odule
stat	tat

Definition at line 303 of file host_node_entities.c.

{
    statement new_stat = copy_statement(stat);
    update_object_for_module(new_stat, module);
    return(new_stat);
}

References copy_statement(), module, and update_object_for_module().

Referenced by generate_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

written_effect_p()

bool written_effect_p	(	entity	var,
		list	le
	)

written_effects_to_dist_arrays_p

Parameters

var	ar
le	e

Definition at line 58 of file hpfc-util.c.

{
  FOREACH(EFFECT, e, le)
    {
      if(store_effect_p(e)) {
        if (reference_variable(effect_any_reference(e))==var &&
            action_write_p(effect_action(e)))
            return true;
      }
    }
 
    return false;
}

References action_write_p, EFFECT, effect_action, effect_any_reference, FOREACH, reference_variable, and store_effect_p().

Referenced by locally_constant_vector_p().

Here is the call graph for this function:

Here is the caller graph for this function:

written_effects_to_dist_arrays_p()

bool written_effects_to_dist_arrays_p

(

expression

expr

)

Parameters

expr

xpr

Definition at line 73 of file hpfc-util.c.

{
    list l, leffects_to_dist_arrays = DistArraysEffects(expr);
 
    // FI: looks like a FOREACH to me...
    for(l=leffects_to_dist_arrays; !ENDP(l); POP(l))
      if(store_effect_p(EFFECT(CAR(l)))) {
        if  (action_write_p(effect_action(EFFECT(CAR(l)))))
        {
            gen_free_list(leffects_to_dist_arrays);
            return true;
        }
      }
 
    gen_free_list(leffects_to_dist_arrays);
    return false;
}

References action_write_p, CAR, DistArraysEffects(), EFFECT, effect_action, ENDP, gen_free_list(), POP, and store_effect_p().

Here is the call graph for this function:

Variable Documentation

dynamic_entity_p

bool(* dynamic_entity_p) (entity) ( entity  )

extern

as expected, true if entity e is dynamic.

it is just a function name nicer than bound_...

Definition at line 145 of file dynamic.c.

Referenced by add_declaration_to_host_and_link(), add_dynamic_synonym(), create_init_common_param_for_arrays(), create_parameters_h(), one_align_directive(), one_distribute_directive(), and set_similar_mappings_for_updates().

host_module

entity host_module

extern

compiler.c

compiler.c

Compiler

stat is the current statement to be compiled, and there are pointers to the current statement building of the node and host codes. the module of these are also kept in order to add the needed declarations generated by the compilation.

however, every entities of the compiled program, and of both generated programs will be mixed, due to the tabulated nature of these objects. some objects will be shared. I don't think this is a problem. global variables

Definition at line 47 of file compiler.c.

Referenced by add_declaration_to_host_and_link(), AddCommonToHostAndNodeModules(), AddEntityToHostAndNodeModules(), compile_module(), generate_c1_beta(), generate_read_of_ref_for_all(), hpf_compile_block(), hpf_compile_call(), hpf_compile_sequential_loop(), hpf_compile_test(), hpfc_common_hook(), hpfc_module_suffix(), init_host_and_node_entities(), NewVariableForModule(), old_name(), put_generated_resources_for_common(), put_generated_resources_for_module(), and update_object_for_module().

node_module

entity node_module

extern

Definition at line 47 of file compiler.c.

Referenced by AddCommonToHostAndNodeModules(), AddEntityToHostAndNodeModules(), compile_module(), extract_lattice(), generate_c1_alpha(), generate_c1_beta(), generate_compute_local_indices(), generate_get_value_locally(), generate_hpf_remapping_file(), generate_optimized_code_for_loop_nest(), generate_parallel_body(), generate_read_of_ref_for_all(), generate_receive_from_computer(), generate_send_to_computer(), hpf_compile_block(), hpf_compile_call(), hpf_compile_parallel_loop(), hpf_compile_sequential_loop(), hpf_compile_test(), hpfc_module_suffix(), init_host_and_node_entities(), Overlap_Analysis(), put_generated_resources_for_common(), put_generated_resources_for_module(), st_compute_current_computer(), st_compute_current_owners(), and st_compute_ith_local_index().