complexity.h File Reference

#include "matrice.h"

Include dependency graph for complexity.h:

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

Go to the source code of this file.

Data Structures
struct	intrinsic_cost_rec
	Intrinsics costs defines. More...

Macros
#define	COMPLEXITY_PACKAGE_NAME   "COMPLEXITY"
	Warning! Do not modify this file that is automatically generated! More...
#define	COMPLEXITY_UNDEFINED   complexity_undefined
#define	COMPLEXITY_UNDEFINED_P(c)   ((c)==complexity_undefined)
#define	COMPLEXITY_NOT_FOUND   ((complexity) HASH_UNDEFINED_VALUE)
#define	MAX_CONTROLS_IN_UNSTRUCTURED   100
#define	UNKNOWN_VARIABLE_NAME   "UNKNOWN_VARIABLE"
	pseudo-variable for unknown variables More...
#define	UNKNOWN_RANGE_NAME   "UNKNOWN_RANGE"
	pseudo-variable for default iteration number of a loop More...
#define	TCST_NAME   "_TCST_"
#define	UNKNOWN_VARIABLE_VALUE_PREFIX   "U_"
	Prefix added to a variable name when its value is unknown but has to be used in a complexity formulae. More...
#define	COST_DATA   "operation index memory trigo transcend overhead"
	defined complexity data file names here. More...
#define	DO_PRINT_STATS   true
	defines for "complexity_fprint" calls More...
#define	DONT_PRINT_STATS   false
#define	PRINT_LOCAL_NAMES   true
#define	PRINT_GLOBAL_NAMES   false
#define	HASH_LOOP_INDEX   ((char *) 4) /**Used as `value' field in the hash-table */
#define	HASH_USER_VARIABLE   ((char *) 8) /**"hash_complexity_parameters"... useful? */
#define	HASH_FORMAL_PARAM   ((char *) 12)
#define	HASH_COMMON_VARIABLE   ((char *) 16) /**used for variable in common. LZ 04/12/91 */
#define	ZERO_BYTE   0
#define	INT_NBYTES   4 /**number of bytes used by a standard int */
#define	FLOAT_NBYTES   4 /**number of bytes used by a single-precision */
#define	DOUBLE_NBYTES   8 /**number of bytes used by a double-precision */
#define	COMPLEX_NBYTES   2*FLOAT_NBYTES /**complex, single-precision */
#define	DCOMPLEX_NBYTES   2*DOUBLE_NBYTES /**complex, double-precision */
#define	MAKE_INT_BASIC   make_basic(is_basic_int, (void *) INT_NBYTES)
#define	MAKE_ADDRESS_BASIC   make_basic(is_basic_int, (void *) DEFAULT_POINTER_TYPE_SIZE)
#define	MAKE_FLOAT_BASIC   make_basic(is_basic_float, (void *) FLOAT_NBYTES)
#define	MAKE_DOUBLE_BASIC   make_basic(is_basic_float, (void *) DOUBLE_NBYTES)
#define	MAKE_COMPLEX_BASIC   make_basic(is_basic_complex, (void *) COMPLEX_NBYTES)
#define	MAKE_DCOMPLEX_BASIC   make_basic(is_basic_complex, (void *) DCOMPLEX_NBYTES)
#define	MAKE_STRING_BASIC   make_basic(is_basic_string, make_value(is_value_unknown, UU))
#define	hash_contains_p(htp, key)   (hash_get(htp, key) != HASH_UNDEFINED_VALUE)
#define	hash_contains_formal_param_p(htp, key)   (hash_get(htp, key) == HASH_FORMAL_PARAM)
#define	hash_contains_user_var_p(htp, key)   (hash_get(htp, key) == HASH_USER_VARIABLE)
#define	hash_contains_common_var_p(htp, key)   (hash_get(htp, key) == HASH_COMMON_VARIABLE)
#define	hash_contains_loop_index_p(htp, key)   (hash_get(htp, key) == HASH_LOOP_INDEX)
#define	KEEP_SYMBOLS   true
	defines for "expression_to_polynome" parameters More...
#define	DONT_KEEP_SYMBOLS   false
#define	MAXIMUM_VALUE   1
#define	MINIMUM_VALUE   -1
#define	EXACT_VALUE   0
#define	TAKE_MAX(m)   ((m) == MAXIMUM_VALUE)
#define	TAKE_MIN(m)   ((m) == MINIMUM_VALUE)
#define	KEEP_EXACT(m)   ((m) == EXACT_VALUE)
#define	LOOP_INIT_OVERHEAD   "LOOP-INIT-OVERHEAD"
#define	LOOP_BRANCH_OVERHEAD   "LOOP-BRANCH-OVERHEAD"
#define	CONDITION_OVERHEAD   "CONDITION-OVERHEAD"
#define	CALL_ZERO_OVERHEAD   "CALL-ZERO-OVERHEAD"
#define	CALL_ONE_OVERHEAD   "CALL-ONE-OVERHEAD"
#define	CALL_TWO_OVERHEAD   "CALL-TWO-OVERHEAD"
#define	CALL_THREE_OVERHEAD   "CALL-THREE-OVERHEAD"
#define	CALL_FOUR_OVERHEAD   "CALL-FOUR-OVERHEAD"
#define	CALL_FIVE_OVERHEAD   "CALL-FIVE-OVERHEAD"
#define	CALL_SIX_OVERHEAD   "CALL-SIX-OVERHEAD"
#define	CALL_SEVEN_OVERHEAD   "CALL-SEVEN-OVERHEAD"
#define	TYPE_CAST_COST   "TypeCast"
	TYPE_CAST_COST added to handle cast case ; Molka Becher More...
#define	MEMORY_READ_NAME   "MEMORY-READ"
	the above two lines are added for 6th cost file, overhead. More...
#define	ONE_INDEX_NAME   "ONE-INDEX" /**to count indexation costs in multi-dim arrays */
#define	TWO_INDEX_NAME   "TWO-INDEX" /**to count indexation costs in multi-dim arrays */
#define	THREE_INDEX_NAME   "THREE-INDEX"
#define	FOUR_INDEX_NAME   "FOUR-INDEX"
#define	FIVE_INDEX_NAME   "FIVE-INDEX"
#define	SIX_INDEX_NAME   "SIX-INDEX"
#define	SEVEN_INDEX_NAME   "SEVEN-INDEX"
#define	STRING_INTRINSICS_COST   1
#define	LOGICAL_INTRINSICS_COST   1
#define	DONT_COUNT_THAT   0, 0, 0, 0, 0
#define	EMPTY_COST   0,0,0,0,0
#define	DISCRIMINE_TYPES   1, 10, 100,1000,10000
#define	REAL_INTRINSIC   100, 100, 100, 100, 100
#define	DOUBLE_INTRINSIC   200, 200, 200, 200, 200
#define	COMPLEX_INTRINSIC   400, 400, 400, 400, 400
#define	MEMORY_READ_COST   DONT_COUNT_THAT
#define	MEMORY_WRITE_COST   DONT_COUNT_THAT
#define	PLUS_MINUS_COST   1, 10, 20, 20, 40
#define	MULTIPLY_COST   PLUS_MINUS_COST
#define	DIVIDE_COST   PLUS_MINUS_COST
#define	POWER_COST   100, 100, 200, 200, 400
#define	TRANSC_COST   REAL_INTRINSIC
#define	DTRANSC_COST   DOUBLE_INTRINSIC
#define	CTRANSC_COST   COMPLEX_INTRINSIC
#define	TRIGO_COST   REAL_INTRINSIC
#define	DTRIGO_COST   DOUBLE_INTRINSIC
#define	CTRIGO_COST   COMPLEX_INTRINSIC
#define	TRIGOH_COST   REAL_INTRINSIC
#define	DTRIGOH_COST   DOUBLE_INTRINSIC
#define	CTRIGOH_COST   COMPLEX_INTRINSIC
#define	TWO_INDEX_COST   DONT_COUNT_THAT
#define	THREE_INDEX_COST   DONT_COUNT_THAT
#define	FOUR_INDEX_COST   DONT_COUNT_THAT
#define	FIVE_INDEX_COST   DONT_COUNT_THAT
#define	SIX_INDEX_COST   DONT_COUNT_THAT
#define	SEVEN_INDEX_COST   DONT_COUNT_THAT

Typedefs
typedef struct intrinsic_cost_rec	intrinsic_cost_record
	Intrinsics costs defines. More...

Functions
bool	complexity_map_undefined_p (void)
void	set_complexity_map (statement_mapping)
statement_mapping	get_complexity_map (void)
void	reset_complexity_map (void)
void	free_complexity_map (void)
void	make_complexity_map (void)
complexity	load_statement_complexity (statement)
void	delete_statement_complexity (statement)
bool	statement_complexity_undefined_p (statement)
void	store_statement_complexity (statement, complexity)
void	update_statement_complexity (statement, complexity)
bool	uniform_complexities (const string)
	declares the static variable complexity_map and defines its access functions More...
bool	fp_complexities (const string)
bool	any_complexities (const string)
bool	summary_complexity (const string)
complexity	statement_to_complexity (statement, transformer, list)
complexity	instruction_to_complexity (instruction, transformer, list)
	The only element available of the statement. More...
complexity	block_to_complexity (list, transformer, list)
	1st element of instruction More...
complexity	test_to_complexity (test, transformer, list)
	2nd element of instruction More...
complexity	loop_to_complexity (loop, transformer, list)
	3rd element of instruction More...
complexity	goto_to_complexity (statement, transformer, list)
complexity	whileloop_to_complexity (whileloop, transformer, list)
	5th element of instruction More...
complexity	call_to_complexity (call, basic *, transformer, list)
	3rd element of syntax More...
complexity	arguments_to_complexity (list, basic *, transformer, list)
	2nd element of call More...
complexity	expression_to_complexity (expression, basic *, transformer, list)
	2nd element of call –arguments More...
complexity	subscript_to_complexity (subscript, basic *, transformer, list)
complexity	syntax_to_complexity (syntax, basic *, transformer, list)
	the only available element of expression More...
complexity	reference_to_complexity (reference, basic *, transformer, list)
	1st element of syntax More...
complexity	indices_to_complexity (list, basic *, transformer, list)
	2nd element of reference More...
complexity	range_to_complexity (range, transformer, list)
	2nd element of syntax More...
char *	noms_var (entity)
	comp_expr_to_pnome.c More...
complexity	make_complexity_unknown (const char *)
	builds a new unknown complexity attached to a virtual package More...
complexity	expression_to_complexity_polynome (expression, transformer, list, bool, int)
	Entry point routine of this file: More...
complexity	syntax_to_polynome (syntax, transformer, list, bool, int)
	1st element of expression More...
complexity	normalized_to_polynome (normalized, transformer, list, bool, int)
	2nd element of expression More...
complexity	pvecteur_to_polynome (Pvecteur, transformer, list, bool, int)
	The only element available of normalized. More...
complexity	reference_to_polynome (reference, transformer, list, bool, int)
	First element of the "syntax" domain. More...
complexity	range_to_polynome (range, transformer, list, bool, int)
complexity	call_to_polynome (call, transformer, list, bool, int)
	3rd element of syntax More...
complexity	cast_to_polynome (cast, transformer, list, bool, int)
	4th element of syntax : Molka Becher More...
complexity	plus_op_handler (list, transformer, list, bool, int)
complexity	minus_op_handler (list, transformer, list, bool, int)
complexity	multiply_op_handler (list, transformer, list, bool, int)
complexity	field_op_handler (list, transformer, list, bool, int)
complexity	unary_minus_op_handler (list, transformer, list, bool, int)
complexity	unary_plus_op_handler (list, transformer, list, bool, int)
complexity	divide_op_handler (list, transformer, list, bool, int)
complexity	power_op_handler (list, transformer, list, bool, int)
complexity	evaluate_var_to_complexity (entity, transformer, list, int)
complexity	simplify_sc_to_complexity (Psysteme, Variable)
	This function is recently added by L.Zhou June 5, 91 simplify_sc_to_complexity(Psysteme ps, Variable var) It looks for the egality formula containing (Variable)var in the system (Psysteme)ps. More...
complexity	unstructured_to_complexity (unstructured, transformer, list)
	comp_unstr.c More...
void	controls_to_hash_table (control, int *, control[], hash_table, transformer, list)
int	control_element_position_in_control_array (control, control[], int)
matrice	average_probability_matrix (unstructured, int, control[])
void	node_successors_to_matrix (control, matrice, int, control[], bool[])
bool	complexity_check (complexity)
	comp_util.c More...
void	complexity_check_and_warn (const char *, complexity)
void	good_complexity_assert (string, complexity)
complexity	complexity_dup (complexity)
	duplicates complexity comp More...
void	complexity_rm (complexity *)
	remove complexity comp More...
char *	complexity_sprint (complexity, bool, bool)
void	complexity_fprint (FILE *, complexity, bool, bool)
void	complexity_dump (complexity)
void	prc (complexity)
void	prp (Ppolynome)
void	prv (Pvecteur)
void	fprint_statement_complexity (entity, statement, hash_table)
void	fprint_cost_table (FILE *)
void	init_cost_table (void)
	Completes the intrinsic cost table with the costs read from the files specified in the "COMPLEXITY_COST_TABLE" string property See properties.rc and ~pips/Pips/pipsrc.csh for more information. More...
void	load_cost_file (FILE *, double)
int	intrinsic_cost (const char *, basic *)
float	constant_entity_to_float (entity)
	Return if possible the value of e in a float. More...
void	trace_on (char *,...)
void	trace_off (void)
	"trace off" More...
bool	is_linear_unstructured (unstructured)
	return true if unstr is simply a linear string of controls More...
list	entity_list_reverse (list)
void	add_formal_parameters_to_hash_table (entity, hash_table)
void	remove_formal_parameters_from_hash_table (entity, hash_table)
hash_table	free_callees_complexities (hash_table)
hash_table	fetch_callees_complexities (char *)
hash_table	fetch_complexity_parameters (char *)
void	add_common_variables_to_hash_table (entity, hash_table)
void	remove_common_variables_from_hash_table (entity, hash_table)
bool	is_must_be_written_var (list, char *)
complexity	final_statement_to_complexity_evaluation (complexity, transformer, list)
complexity	translate_complexity_from_local_to_current_name (complexity, string, string)
	translate_complexity_from_local_to_current_name(callee_comp,oldname,newname) B:M -> A:M if A calls B 5 Feb. More...
bool	complexity_is_monomial_p (complexity)
int	complexity_degree (complexity)
complexity	complexity_sigma (complexity, Variable, complexity, complexity)
	comp_math.c More...
complexity	complexity_var_subst (complexity, Variable, complexity)
	complexity complexity_var_subst(comp, var, compsubst) replaces every occurrence of variable var in complexity comp by the polynomial of complexity compsubst. More...
complexity	polynome_to_new_complexity (Ppolynome)
	Create a complexity equal to Ppolynome pp with null statistics. More...
complexity	make_single_var_complexity (double, Variable)
complexity	make_constant_complexity (double)
complexity	make_zero_complexity (void)
	make a zero complexity "0.0000 * TCST" with null statistics More...
bool	complexity_zero_p (complexity)
	zero complexity check. More...
bool	complexity_constant_p (complexity)
	true if comp is constant. More...
bool	complexity_unknown_p (complexity)
	true if comp is unknown. More...
float	complexity_TCST (complexity)
	return the constant term of comp. More...
void	complexity_scalar_mult (complexity *, double)
void	complexity_stats_add (complexity *, complexity)
	Add comp2's statistics to *pcomp1's comp2 keeps unchanged. More...
void	complexity_add (complexity *, complexity)
	void complexity_add(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 + comp2; !usage: complexity_add(&comp1, comp2); comp2 keeps unchanged More...
void	complexity_sub (complexity *, complexity)
	void complexity_sub(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 - comp2; !usage: complexity_sub(&comp1, comp2); comp2 keeps unchanged More...
void	complexity_mult (complexity *, complexity)
	void complexity_mult(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 * comp2; !usage: complexity_mult(&comp1, comp2); More...
void	complexity_div (complexity *, complexity)
	void complexity_div(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 / comp2; !usage: complexity_div(&comp1, comp2); More...
void	complexity_polynome_add (complexity *, Ppolynome)
void	complexity_float_add (complexity *, double)
Ppolynome	complexity_polynome (complexity)
	Because complexity is composed of two elements, we use this function to get the first element : polynome Usage : complexity_polynome(complexity comp) you will get a pointer to the polynome May 3, 91 lz. More...
complexity	replace_formal_parameters_by_real_ones (complexity, entity, list, transformer, list)
	transform formal params into real ones (args) in complexity comp More...
list	list_ith_element (list, int)
	return a pointer to the (i)th element of the list if i = 1, the pointer doesn't change at all. More...
bool	print_code_complexities (const string)
	comp_prettyprint.c More...
bool	print_code_as_a_graph_complexities (const string)
bool	print_source_complexities (const string)
bool	print_call_graph_with_complexities (const string)
bool	print_icfg_with_complexities (const string)
bool	print_icfg_with_loops_complexities (const string)
bool	print_icfg_with_control_complexities (const string)
char *	variable_name (Variable)
	polynome_ri.c More...
char *	variable_local_name (Variable)
bool	is_inferior_var (Variable, Variable)
int	is_inferior_varval (Pvecteur, Pvecteur)
int	is_inferior_pvarval (Pvecteur *, Pvecteur *)
Variable	name_to_variable (char *)
Variable	local_name_to_variable (char *)
void	lu_decomposition (float *, int, int *, int *)
	comp_matrice.c More...
void	lu_back_substitution (float *, int, int *, float *)
void	float_matrice_inversion (float *, int, int *, int *)

Variables
hash_table	hash_callee_to_complexity
	cproto-generated files More...
hash_table	hash_complexity_parameters
intrinsic_cost_record	intrinsic_cost_table []
	The table intrinsic_cost_table[] gathers cost information of each intrinsic's cost; those costs are dynamically loaded from user files. More...

Macro Definition Documentation

CALL_FIVE_OVERHEAD

#define CALL_FIVE_OVERHEAD   "CALL-FIVE-OVERHEAD"

Definition at line 137 of file complexity.h.

CALL_FOUR_OVERHEAD

#define CALL_FOUR_OVERHEAD   "CALL-FOUR-OVERHEAD"

Definition at line 136 of file complexity.h.

CALL_ONE_OVERHEAD

#define CALL_ONE_OVERHEAD   "CALL-ONE-OVERHEAD"

Definition at line 133 of file complexity.h.

CALL_SEVEN_OVERHEAD

#define CALL_SEVEN_OVERHEAD   "CALL-SEVEN-OVERHEAD"

Definition at line 139 of file complexity.h.

CALL_SIX_OVERHEAD

#define CALL_SIX_OVERHEAD   "CALL-SIX-OVERHEAD"

Definition at line 138 of file complexity.h.

CALL_THREE_OVERHEAD

#define CALL_THREE_OVERHEAD   "CALL-THREE-OVERHEAD"

Definition at line 135 of file complexity.h.

CALL_TWO_OVERHEAD

#define CALL_TWO_OVERHEAD   "CALL-TWO-OVERHEAD"

Definition at line 134 of file complexity.h.

CALL_ZERO_OVERHEAD

#define CALL_ZERO_OVERHEAD   "CALL-ZERO-OVERHEAD"

Definition at line 132 of file complexity.h.

COMPLEX_INTRINSIC

#define COMPLEX_INTRINSIC   400, 400, 400, 400, 400

Definition at line 163 of file complexity.h.

COMPLEX_NBYTES

#define COMPLEX_NBYTES   2*FLOAT_NBYTES /**complex, single-precision */

Definition at line 88 of file complexity.h.

COMPLEXITY_NOT_FOUND

#define COMPLEXITY_NOT_FOUND   ((complexity) HASH_UNDEFINED_VALUE)

Definition at line 53 of file complexity.h.

COMPLEXITY_PACKAGE_NAME

#define COMPLEXITY_PACKAGE_NAME   "COMPLEXITY"

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

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

Definition at line 47 of file complexity.h.

COMPLEXITY_UNDEFINED

#define COMPLEXITY_UNDEFINED   complexity_undefined

Definition at line 48 of file complexity.h.

COMPLEXITY_UNDEFINED_P

#define COMPLEXITY_UNDEFINED_P

(

c

)

((c)==complexity_undefined)

Definition at line 52 of file complexity.h.

CONDITION_OVERHEAD

#define CONDITION_OVERHEAD   "CONDITION-OVERHEAD"

Definition at line 130 of file complexity.h.

COST_DATA

#define COST_DATA   "operation index memory trigo transcend overhead"

defined complexity data file names here.

LZ 13/03/92

Definition at line 71 of file complexity.h.

CTRANSC_COST

#define CTRANSC_COST   COMPLEX_INTRINSIC

Definition at line 178 of file complexity.h.

CTRIGO_COST

#define CTRIGO_COST   COMPLEX_INTRINSIC

Definition at line 181 of file complexity.h.

CTRIGOH_COST

#define CTRIGOH_COST   COMPLEX_INTRINSIC

Definition at line 184 of file complexity.h.

DCOMPLEX_NBYTES

#define DCOMPLEX_NBYTES   2*DOUBLE_NBYTES /**complex, double-precision */

Definition at line 89 of file complexity.h.

DISCRIMINE_TYPES

#define DISCRIMINE_TYPES   1, 10, 100,1000,10000

Definition at line 160 of file complexity.h.

DIVIDE_COST

#define DIVIDE_COST   PLUS_MINUS_COST

Definition at line 173 of file complexity.h.

DO_PRINT_STATS

#define DO_PRINT_STATS   true

defines for "complexity_fprint" calls

Definition at line 74 of file complexity.h.

DONT_COUNT_THAT

#define DONT_COUNT_THAT   0, 0, 0, 0, 0

Definition at line 158 of file complexity.h.

DONT_KEEP_SYMBOLS

#define DONT_KEEP_SYMBOLS   false

Definition at line 107 of file complexity.h.

DONT_PRINT_STATS

#define DONT_PRINT_STATS   false

Definition at line 75 of file complexity.h.

DOUBLE_INTRINSIC

#define DOUBLE_INTRINSIC   200, 200, 200, 200, 200

Definition at line 162 of file complexity.h.

DOUBLE_NBYTES

#define DOUBLE_NBYTES   8 /**number of bytes used by a double-precision */

Definition at line 87 of file complexity.h.

DTRANSC_COST

#define DTRANSC_COST   DOUBLE_INTRINSIC

Definition at line 177 of file complexity.h.

DTRIGO_COST

#define DTRIGO_COST   DOUBLE_INTRINSIC

Definition at line 180 of file complexity.h.

DTRIGOH_COST

#define DTRIGOH_COST   DOUBLE_INTRINSIC

Definition at line 183 of file complexity.h.

EMPTY_COST

#define EMPTY_COST   0,0,0,0,0

Definition at line 159 of file complexity.h.

EXACT_VALUE

#define EXACT_VALUE   0

Definition at line 110 of file complexity.h.

FIVE_INDEX_COST

#define FIVE_INDEX_COST   DONT_COUNT_THAT

Definition at line 189 of file complexity.h.

FIVE_INDEX_NAME

#define FIVE_INDEX_NAME   "FIVE-INDEX"

Definition at line 152 of file complexity.h.

FLOAT_NBYTES

#define FLOAT_NBYTES   4 /**number of bytes used by a single-precision */

Definition at line 86 of file complexity.h.

FOUR_INDEX_COST

#define FOUR_INDEX_COST   DONT_COUNT_THAT

Definition at line 188 of file complexity.h.

FOUR_INDEX_NAME

#define FOUR_INDEX_NAME   "FOUR-INDEX"

Definition at line 151 of file complexity.h.

HASH_COMMON_VARIABLE

#define HASH_COMMON_VARIABLE   ((char *) 16) /**used for variable in common. LZ 04/12/91 */

Definition at line 82 of file complexity.h.

hash_contains_common_var_p

#define hash_contains_common_var_p	(		htp,
			key
	)		(hash_get(htp, key) == HASH_COMMON_VARIABLE)

Definition at line 101 of file complexity.h.

hash_contains_formal_param_p

#define hash_contains_formal_param_p	(		htp,
			key
	)		(hash_get(htp, key) == HASH_FORMAL_PARAM)

Definition at line 99 of file complexity.h.

hash_contains_loop_index_p

#define hash_contains_loop_index_p	(		htp,
			key
	)		(hash_get(htp, key) == HASH_LOOP_INDEX)

Definition at line 102 of file complexity.h.

hash_contains_p

#define hash_contains_p	(		htp,
			key
	)		(hash_get(htp, key) != HASH_UNDEFINED_VALUE)

Definition at line 98 of file complexity.h.

hash_contains_user_var_p

#define hash_contains_user_var_p	(		htp,
			key
	)		(hash_get(htp, key) == HASH_USER_VARIABLE)

Definition at line 100 of file complexity.h.

HASH_FORMAL_PARAM

#define HASH_FORMAL_PARAM   ((char *) 12)

Definition at line 81 of file complexity.h.

HASH_LOOP_INDEX

#define HASH_LOOP_INDEX   ((char *) 4) /**Used as `value' field in the hash-table */

Definition at line 79 of file complexity.h.

HASH_USER_VARIABLE

#define HASH_USER_VARIABLE   ((char *) 8) /**"hash_complexity_parameters"... useful? */

Definition at line 80 of file complexity.h.

INT_NBYTES

#define INT_NBYTES   4 /**number of bytes used by a standard int */

Definition at line 85 of file complexity.h.

KEEP_EXACT

#define KEEP_EXACT

(

m

)

((m) == EXACT_VALUE)

Definition at line 113 of file complexity.h.

KEEP_SYMBOLS

#define KEEP_SYMBOLS   true

defines for "expression_to_polynome" parameters

Definition at line 106 of file complexity.h.

LOGICAL_INTRINSICS_COST

#define LOGICAL_INTRINSICS_COST   1

Definition at line 156 of file complexity.h.

LOOP_BRANCH_OVERHEAD

#define LOOP_BRANCH_OVERHEAD   "LOOP-BRANCH-OVERHEAD"

Definition at line 129 of file complexity.h.

LOOP_INIT_OVERHEAD

#define LOOP_INIT_OVERHEAD   "LOOP-INIT-OVERHEAD"

Definition at line 128 of file complexity.h.

MAKE_ADDRESS_BASIC

#define MAKE_ADDRESS_BASIC   make_basic(is_basic_int, (void *) DEFAULT_POINTER_TYPE_SIZE)

Definition at line 91 of file complexity.h.

MAKE_COMPLEX_BASIC

#define MAKE_COMPLEX_BASIC   make_basic(is_basic_complex, (void *) COMPLEX_NBYTES)

Definition at line 94 of file complexity.h.

MAKE_DCOMPLEX_BASIC

#define MAKE_DCOMPLEX_BASIC   make_basic(is_basic_complex, (void *) DCOMPLEX_NBYTES)

Definition at line 95 of file complexity.h.

MAKE_DOUBLE_BASIC

#define MAKE_DOUBLE_BASIC   make_basic(is_basic_float, (void *) DOUBLE_NBYTES)

Definition at line 93 of file complexity.h.

MAKE_FLOAT_BASIC

#define MAKE_FLOAT_BASIC   make_basic(is_basic_float, (void *) FLOAT_NBYTES)

Definition at line 92 of file complexity.h.

MAKE_INT_BASIC

#define MAKE_INT_BASIC   make_basic(is_basic_int, (void *) INT_NBYTES)

Definition at line 90 of file complexity.h.

MAKE_STRING_BASIC

#define MAKE_STRING_BASIC   make_basic(is_basic_string, make_value(is_value_unknown, UU))

Definition at line 96 of file complexity.h.

MAX_CONTROLS_IN_UNSTRUCTURED

#define MAX_CONTROLS_IN_UNSTRUCTURED   100

Definition at line 55 of file complexity.h.

MAXIMUM_VALUE

#define MAXIMUM_VALUE   1

Definition at line 108 of file complexity.h.

MEMORY_READ_COST

#define MEMORY_READ_COST   DONT_COUNT_THAT

Definition at line 165 of file complexity.h.

MEMORY_READ_NAME

#define MEMORY_READ_NAME   "MEMORY-READ"

the above two lines are added for 6th cost file, overhead.

LZ 280993 overhead is divided into two. init and branch 081093

Definition at line 147 of file complexity.h.

MEMORY_WRITE_COST

#define MEMORY_WRITE_COST   DONT_COUNT_THAT

Definition at line 166 of file complexity.h.

MINIMUM_VALUE

#define MINIMUM_VALUE   -1

Definition at line 109 of file complexity.h.

MULTIPLY_COST

#define MULTIPLY_COST   PLUS_MINUS_COST

Definition at line 172 of file complexity.h.

ONE_INDEX_NAME

#define ONE_INDEX_NAME   "ONE-INDEX" /**to count indexation costs in multi-dim arrays */

Definition at line 148 of file complexity.h.

PLUS_MINUS_COST

#define PLUS_MINUS_COST   1, 10, 20, 20, 40

Definition at line 167 of file complexity.h.

POWER_COST

#define POWER_COST   100, 100, 200, 200, 400

Definition at line 174 of file complexity.h.

PRINT_GLOBAL_NAMES

#define PRINT_GLOBAL_NAMES   false

Definition at line 77 of file complexity.h.

PRINT_LOCAL_NAMES

#define PRINT_LOCAL_NAMES   true

Definition at line 76 of file complexity.h.

REAL_INTRINSIC

#define REAL_INTRINSIC   100, 100, 100, 100, 100

Definition at line 161 of file complexity.h.

SEVEN_INDEX_COST

#define SEVEN_INDEX_COST   DONT_COUNT_THAT

Definition at line 191 of file complexity.h.

SEVEN_INDEX_NAME

#define SEVEN_INDEX_NAME   "SEVEN-INDEX"

Definition at line 154 of file complexity.h.

SIX_INDEX_COST

#define SIX_INDEX_COST   DONT_COUNT_THAT

Definition at line 190 of file complexity.h.

SIX_INDEX_NAME

#define SIX_INDEX_NAME   "SIX-INDEX"

Definition at line 153 of file complexity.h.

STRING_INTRINSICS_COST

#define STRING_INTRINSICS_COST   1

Definition at line 155 of file complexity.h.

TAKE_MAX

#define TAKE_MAX

(

m

)

((m) == MAXIMUM_VALUE)

Definition at line 111 of file complexity.h.

TAKE_MIN

#define TAKE_MIN

(

m

)

((m) == MINIMUM_VALUE)

Definition at line 112 of file complexity.h.

TCST_NAME

#define TCST_NAME   "_TCST_"

Definition at line 63 of file complexity.h.

THREE_INDEX_COST

#define THREE_INDEX_COST   DONT_COUNT_THAT

Definition at line 187 of file complexity.h.

THREE_INDEX_NAME

#define THREE_INDEX_NAME   "THREE-INDEX"

Definition at line 150 of file complexity.h.

TRANSC_COST

#define TRANSC_COST   REAL_INTRINSIC

Definition at line 176 of file complexity.h.

TRIGO_COST

#define TRIGO_COST   REAL_INTRINSIC

Definition at line 179 of file complexity.h.

TRIGOH_COST

#define TRIGOH_COST   REAL_INTRINSIC

Definition at line 182 of file complexity.h.

TWO_INDEX_COST

#define TWO_INDEX_COST   DONT_COUNT_THAT

Definition at line 186 of file complexity.h.

TWO_INDEX_NAME

#define TWO_INDEX_NAME   "TWO-INDEX" /**to count indexation costs in multi-dim arrays */

Definition at line 149 of file complexity.h.

TYPE_CAST_COST

#define TYPE_CAST_COST   "TypeCast"

TYPE_CAST_COST added to handle cast case ; Molka Becher

Definition at line 142 of file complexity.h.

UNKNOWN_RANGE_NAME

#define UNKNOWN_RANGE_NAME   "UNKNOWN_RANGE"

pseudo-variable for default iteration number of a loop

Definition at line 61 of file complexity.h.

UNKNOWN_VARIABLE_NAME

#define UNKNOWN_VARIABLE_NAME   "UNKNOWN_VARIABLE"

pseudo-variable for unknown variables

Definition at line 58 of file complexity.h.

UNKNOWN_VARIABLE_VALUE_PREFIX

#define UNKNOWN_VARIABLE_VALUE_PREFIX   "U_"

Prefix added to a variable name when its value is unknown but has to be used in a complexity formulae.

Definition at line 68 of file complexity.h.

ZERO_BYTE

#define ZERO_BYTE   0

Definition at line 84 of file complexity.h.

Typedef Documentation

intrinsic_cost_record

typedef struct intrinsic_cost_rec intrinsic_cost_record

Intrinsics costs defines.

Function Documentation

add_common_variables_to_hash_table()

void add_common_variables_to_hash_table	(	entity	module,
		hash_table	hash_complexity_params
	)

Parameters

module	odule
hash_complexity_params	ash_complexity_params

Definition at line 946 of file comp_util.c.

{
    const char* module_name = module_local_name(module);
    list sefs_list = list_undefined;
    list ce = list_undefined;
 
    pips_assert("add_common_variables_to_hash_table",
                entity_module_p(module));
 
    sefs_list = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
    ifdebug(5) {
        debug(5, "add_common_variables_to_hash_table",
              "Effect list for %s\n",
              module_name);
        print_effects(sefs_list);
    }
 
    for(ce= sefs_list; !ENDP(ce); POP(ce)) {
        effect obj = EFFECT(CAR(ce));
        reference r = effect_any_reference(obj);
        action ac = effect_action(obj);
        approximation ap = effect_approximation(obj);
        entity e = reference_variable(r);
        storage s = entity_storage(e);
 
        if ( !storage_formal_p(s) &&
            action_read_p(ac) && approximation_exact_p(ap) ) {
            debug(5,"add_common_variables_to_hash_table",
                  "%s added\n", module_local_name(e));
            hash_put(hash_complexity_params, (char *) module_local_name(e),
                     HASH_COMMON_VARIABLE);
        }
    }
}

References action_read_p, approximation_exact_p, CAR, db_get_memory_resource(), debug(), EFFECT, effect_action, effect_any_reference, effect_approximation, effects_to_list(), ENDP, entity_module_p(), entity_storage, HASH_COMMON_VARIABLE, hash_put(), ifdebug, list_undefined, module, module_local_name(), module_name(), pips_assert, POP, print_effects, reference_variable, and storage_formal_p.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_formal_parameters_to_hash_table()

void add_formal_parameters_to_hash_table	(	entity	mod,
		hash_table	hash_complexity_params
	)

Parameters

mod	od
hash_complexity_params	ash_complexity_params

Definition at line 768 of file comp_util.c.

{
    list decl;
 
    pips_assert("add_formal_parameters_to_hash_table",
                entity_module_p(mod));
    decl = code_declarations(value_code(entity_initial(mod)));
 
    MAPL(pe, {
        entity param = ENTITY(CAR(pe));
        if (storage_formal_p(entity_storage(param))) {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr,"\nstorage_formal %s\n",
                        entity_name(param));
            }
            hash_put(hash_complexity_params, (char *) strdup(module_local_name(param)),
                     HASH_FORMAL_PARAM);
        }
    }, decl);
}

References CAR, code_declarations, ENTITY, entity_initial, entity_module_p(), entity_name, entity_storage, fprintf(), get_bool_property(), HASH_FORMAL_PARAM, hash_put(), MAPL, module_local_name(), pips_assert, storage_formal_p, strdup(), and value_code.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

any_complexities()

bool any_complexities

(

const

string

)

we may need to print preconditions for debugging purposes

Parameters

string

odule_name

Definition at line 99 of file comp_scan.c.

{
    transformer precond = transformer_undefined;
    list effects_list = NIL;
    entity module_entity;
    statement module_stat;
 
    trace_on("complexities %s", (char *)module_name);
    debug_on("COMPLEXITY_DEBUG_LEVEL");
 
    /* we may need to print preconditions for debugging purposes */
    set_precondition_map( (statement_mapping)
        db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
    set_cumulated_rw_effects((statement_effects)
        db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_proper_rw_effects((statement_effects)
        db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    set_current_module_entity(module_name_to_entity(module_name));
    set_current_module_statement( (statement)
        db_get_memory_resource(DBR_CODE, module_name, true ) );
 
    module_entity = get_current_module_entity();
    module_stat = get_current_module_statement();
 
    module_to_value_mappings(module_entity);
 
    precond = load_statement_precondition(module_stat);
    effects_list = load_cumulated_rw_effects_list(module_stat);
 
    init_cost_table();
 
    if (get_bool_property("COMPLEXITY_PRINT_COST_TABLE"))
        fprint_cost_table(stdout);
 
    set_complexity_map( MAKE_STATEMENT_MAPPING() );
 
    hash_callee_to_complexity = fetch_callees_complexities(module_name);
    hash_complexity_parameters = fetch_complexity_parameters(module_name);
 
    add_formal_parameters_to_hash_table(module_entity,
                                        hash_complexity_parameters);
 
    add_common_variables_to_hash_table(module_entity,
                                       hash_complexity_parameters);
 
    (void)statement_to_complexity(module_stat, precond, effects_list);
 
    remove_common_variables_from_hash_table(module_entity,
                                            hash_complexity_parameters);
 
    remove_formal_parameters_from_hash_table(module_entity, 
                                             hash_complexity_parameters);
    debug_off();
    trace_off();
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr,"\n");
        fprintf(stderr,"Before  ------- COMPLEXITIES; module %s\n",module_name);
    }
 
    DB_PUT_MEMORY_RESOURCE(DBR_COMPLEXITIES,
                           strdup(module_name),
                           (char *) get_complexity_map() );
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr,"After   ------- COMPLEXITIES; module %s\n",module_name);
    }
 
    hash_callee_to_complexity =
        free_callees_complexities(hash_callee_to_complexity);
    reset_precondition_map();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_complexity_map();
    reset_current_module_entity();
    reset_current_module_statement();
    free_value_mappings();
 
    return true;
}

References add_common_variables_to_hash_table(), add_formal_parameters_to_hash_table(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, fetch_callees_complexities(), fetch_complexity_parameters(), fprint_cost_table(), fprintf(), free_callees_complexities(), free_value_mappings(), get_bool_property(), get_complexity_map(), get_current_module_entity(), get_current_module_statement(), hash_callee_to_complexity, hash_complexity_parameters, init_cost_table(), load_cumulated_rw_effects_list(), load_statement_precondition(), MAKE_STATEMENT_MAPPING, module_name(), module_name_to_entity(), module_to_value_mappings(), NIL, remove_common_variables_from_hash_table(), remove_formal_parameters_from_hash_table(), reset_complexity_map(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), set_complexity_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), statement_to_complexity(), strdup(), trace_off(), trace_on(), and transformer_undefined.

Referenced by fp_complexities(), and uniform_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

arguments_to_complexity()

complexity arguments_to_complexity	(	list	exprlist,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

2nd element of call

arguments_to_complexity Return the sum of the complexities of the list of expressions passed. Return also in *pbasic the basic of the "biggest" argument (int/float/double/...)

Parameters

exprlist	xprlist
pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 804 of file comp_scan.c.

{
    complexity comp = make_zero_complexity();
    basic abasic = MAKE_INT_BASIC;
 
    trace_on("arguments");
 
    *pbasic = MAKE_INT_BASIC;
    MAPL (pa, {
        expression e = EXPRESSION(CAR(pa));
        complexity ctmp = expression_to_complexity(e, &abasic, precond, effects_list);
        complexity_add(&comp, ctmp);
        if (is_inferior_basic(*pbasic, abasic)) {
            free_basic(*pbasic);
            *pbasic = simple_basic_dup(abasic);
        }
    },exprlist);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "argument comp is at %p and value is ", comp);
        complexity_fprint(stderr, comp, false, true);
    }
    complexity_check_and_warn("arguments_to_complexity", comp);
 
    trace_off();
    return(comp);
}

References CAR, complexity_add(), complexity_check_and_warn(), complexity_fprint(), EXPRESSION, expression_to_complexity(), fprintf(), free_basic(), get_bool_property(), is_inferior_basic(), MAKE_INT_BASIC, make_zero_complexity(), MAPL, simple_basic_dup(), trace_off(), and trace_on().

Referenced by call_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

average_probability_matrix()

matrice average_probability_matrix	(	unstructured	,
		int	,
		control	[]
	)

block_to_complexity()

complexity block_to_complexity	(	list	block,
		transformer	precond,
		list	effects_list
	)

1st element of instruction

Modification:

• To postpone the variable evaluation, we reverse the block. Attention: gen_nreverse destroys the original list. LZ 4 Dec. 92
• Secondly, we check the variables in complexity. If a certain variable is must_be_written variable ( obtained from cumulated effects ), we evaluate it. LZ 5 Dec. 92
• When the variable is must_be_written, the precondition is no longer available with this effect. So we need to use the next statement effect with current precondition to evaluate the variable. LZ 9 Dec. 92
• Francois suggested not to create new list, ie, reverse block. Hence we don't use MAPL any more here. Instead, gen_nthcdr is used. 16 Dec 92

Parameters

block	lock
precond	recond
effects_list	ffects_list

Definition at line 344 of file comp_scan.c.

{
  complexity comp = make_zero_complexity();
  int block_length = gen_length( block );
  int i;
 
  trace_on("block");
 
  if (get_bool_property("COMPLEXITY_EARLY_EVALUATION")) {
    FOREACH(STATEMENT, stat, block) {
      complexity ctemp = statement_to_complexity(stat, precond, effects_list);
      complexity_add(&comp, ctemp);
    }
  }
  else { // default property setting
    for ( i = block_length; i > 0 ; i-- ) {
      statement stat = STATEMENT(CAR(gen_nthcdr( i-1, block )));
      statement up_stat;
      transformer prec = load_statement_precondition(stat);
      complexity ctemp = statement_to_complexity(stat,
                                                 prec, effects_list);
 
      list cumu_list = load_cumulated_rw_effects_list(stat);
      //extern int default_is_inferior_pvarval(Pvecteur *, Pvecteur *);
 
      Pbase pb = VECTEUR_NUL;
 
      if ( i > 1 ) {
        up_stat = STATEMENT(CAR(gen_nthcdr( i-2, block )));
        cumu_list = load_cumulated_rw_effects_list(up_stat);
      }
      complexity_add(&comp, ctemp);
 
      pb = vect_dup(polynome_used_var(complexity_polynome(comp),
                                      default_is_inferior_pvarval));
 
      for ( ; !VECTEUR_NUL_P(pb); pb = pb->succ) {
        bool mustbewritten;
        entity v = (entity) (pb->var);
        //char *var = variable_local_name(pb->var);
 
        //mustbewritten = is_must_be_written_var(cumu_list, var);
        mustbewritten = effects_write_variable_p(cumu_list, v);
 
        if ( mustbewritten ) {
          complexity csubst;
 
          csubst = evaluate_var_to_complexity((entity)pb->var,
                                              prec,
                                              cumu_list, 1);
          comp = complexity_var_subst(comp, pb->var, csubst);
        }
      }
    }
  }
 
  if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
    (void) complexity_consistent_p(comp);
    fprintf(stderr, "block comp is at %p and comp value is ", comp);
    complexity_fprint(stderr, comp, false, true);
  }
  complexity_check_and_warn("block_to_complexity", comp);
 
  trace_off();
  return(comp);
}

References CAR, complexity_add(), complexity_check_and_warn(), complexity_consistent_p(), complexity_fprint(), complexity_polynome(), complexity_var_subst(), default_is_inferior_pvarval(), effects_write_variable_p(), evaluate_var_to_complexity(), FOREACH, fprintf(), gen_length(), gen_nthcdr(), get_bool_property(), load_cumulated_rw_effects_list(), load_statement_precondition(), make_zero_complexity(), polynome_used_var(), STATEMENT, statement_to_complexity(), Svecteur::succ, trace_off(), trace_on(), Svecteur::var, vect_dup(), VECTEUR_NUL, and VECTEUR_NUL_P.

Referenced by instruction_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

call_to_complexity()

complexity call_to_complexity	(	call	call_instr,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

3rd element of syntax

The only case that hash_callee_to_complexity is used

transform formal params into real ones

if not format case

Parameters

call_instr	all_instr
pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 736 of file comp_scan.c.

{
    complexity comp = make_zero_complexity();
    entity f = call_function(call_instr);
    list args= call_arguments(call_instr);
    type   t = entity_type(f);
    value  v = entity_initial(f);
 
    const char *name = module_local_name(f);
 
    trace_on("call %s", entity_name(f));
 
    pips_assert("call_to_complexity",
                type_statement_p(t)||type_functional_p(t)||type_void_p(t));
 
    switch (value_tag(v)) {
    case is_value_code: {
        complexity compcallee;
 
        /* The only case that hash_callee_to_complexity is used */
        compcallee = (complexity) hash_get(hash_callee_to_complexity, 
                                           (char *) f);
        if ( compcallee == COMPLEXITY_NOT_FOUND )
            user_error("call_to_complexity", "unknown complexity\n");
        /* transform formal params into real ones */
        comp = replace_formal_parameters_by_real_ones(compcallee, 
                                                      f, args, 
                                                      precond, 
                                                      effects_list);
        break;
    }
    case is_value_symbolic:
    case is_value_constant:
        if ( !type_statement_p(t) )            /* if not format case */
            *pbasic = entity_basic(f);
        comp = make_zero_complexity();
        break;
    case is_value_intrinsic:
        comp = arguments_to_complexity(args, pbasic, precond, effects_list);
        complexity_float_add(&comp, (float) intrinsic_cost(name, pbasic));
        break;
    case is_value_unknown:
        user_error("call_to_complexity", "unknown value");
    default:
        pips_internal_error("value_tag is %d not in 37->41", (int)value_tag(v));
    }
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "call '%s': ", name);
        complexity_fprint(stderr, comp, false, true);
        fprintf(stderr, "call comp is at %p\n", comp);
    }
    complexity_check_and_warn("call_to_complexity", comp);
 
    trace_off();
    return(comp);
}

References arguments_to_complexity(), call_arguments, call_function, complexity_check_and_warn(), complexity_float_add(), complexity_fprint(), COMPLEXITY_NOT_FOUND, entity_basic(), entity_initial, entity_name, entity_type, f(), fprintf(), get_bool_property(), hash_callee_to_complexity, hash_get(), intrinsic_cost(), is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_zero_complexity(), module_local_name(), pips_assert, pips_internal_error, replace_formal_parameters_by_real_ones(), trace_off(), trace_on(), type_functional_p, type_statement_p, type_void_p, user_error, and value_tag.

Referenced by instruction_to_complexity(), and syntax_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

call_to_polynome()

complexity call_to_polynome	(	call	call_instr,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

3rd element of syntax

For the moment, we don't want to evaluate the complexity of the

function defined by the users

Parameters

call_instr	all_instr
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 369 of file comp_expr_to_pnome.c.

{
    entity f = call_function(call_instr);
    const char *name = module_local_name(f);
    list args = call_arguments(call_instr);
    type t = entity_type(f);
    value v = entity_initial(f);
    complexity comp = make_zero_complexity();
 
    trace_on("CALL '%s' -> pnome", name);
 
    if (!type_functional_p(t) ||
        (value_intrinsic_p(v) && value_code_p(v) && value_constant_p(v)))
        pips_internal_error("'%s' isn't an expected entity (type %d, value %d)",
                   type_tag(t), value_tag(v), name);
 
    switch (value_tag(v)) {
    case is_value_code:
        /* For the moment, we don't want to evaluate the complexity of the   */
        break;                       /* function defined by the users    */
    case is_value_constant:
          complexity_float_add(&comp, constant_entity_to_float(f));
          break;
    case is_value_intrinsic:
          if (same_string_p(name, PLUS_OPERATOR_NAME))
            comp = plus_op_handler(args, precond, effects_list, keep_symbols, maximize);
          else if (same_string_p(name, MINUS_OPERATOR_NAME))
            comp = minus_op_handler(args, precond, effects_list, keep_symbols, maximize);
      else if (same_string_p(name, MULTIPLY_OPERATOR_NAME))
            comp = multiply_op_handler(args, precond, effects_list, keep_symbols, maximize);
      else if (same_string_p(name, DIVIDE_OPERATOR_NAME))
            comp = divide_op_handler(args, precond, effects_list, keep_symbols, maximize);
      else if (same_string_p(name, POWER_OPERATOR_NAME))
        comp = power_op_handler(args, precond, effects_list, keep_symbols, maximize);
      else if (same_string_p(name, UNARY_MINUS_OPERATOR_NAME))
        comp = unary_minus_op_handler(args, precond, effects_list, keep_symbols, maximize);
      else if (same_string_p(name, FIELD_OPERATOR_NAME))
        comp = field_op_handler(args, precond, effects_list, keep_symbols, maximize);
      else
        pips_user_warning("operator '%s' skipped\n",name);
          break;
 
    default:
      pips_internal_error("not handled case");
    }
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
          fprintf(stderr, "call->pnome '%s': ", name);
          complexity_fprint(stderr, comp, true, true);
    }
 
    trace_off();
    return (comp);
}

References call_arguments, call_function, complexity_float_add(), complexity_fprint(), constant_entity_to_float(), divide_op_handler(), DIVIDE_OPERATOR_NAME, entity_initial, entity_type, f(), field_op_handler(), FIELD_OPERATOR_NAME, fprintf(), get_bool_property(), is_value_code, is_value_constant, is_value_intrinsic, make_zero_complexity(), minus_op_handler(), MINUS_OPERATOR_NAME, module_local_name(), multiply_op_handler(), MULTIPLY_OPERATOR_NAME, pips_internal_error, pips_user_warning, plus_op_handler(), PLUS_OPERATOR_NAME, power_op_handler(), POWER_OPERATOR_NAME, same_string_p, trace_off(), trace_on(), type_functional_p, type_tag, unary_minus_op_handler(), UNARY_MINUS_OPERATOR_NAME, value_code_p, value_constant_p, value_intrinsic_p, and value_tag.

Referenced by syntax_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

cast_to_polynome()

complexity cast_to_polynome	(	cast	cast_instr,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

4th element of syntax : Molka Becher

Parameters

cast_instr	ast_instr
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 429 of file comp_expr_to_pnome.c.

{
  expression exp = cast_expression(cast_instr);
 
  trace_on("CAST");
 
  complexity comp = expression_to_complexity_polynome(exp, precond, effects_list,
                                                      keep_symbols, maximize);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "cast->pnome");
        complexity_fprint(stderr, comp, true, true);
    }
 
  trace_off();
  return (comp);
}

References cast_expression, complexity_fprint(), exp, expression_to_complexity_polynome(), fprintf(), get_bool_property(), trace_off(), and trace_on().

Referenced by syntax_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_add()

void complexity_add	(	complexity *	pcomp1,
		complexity	comp2
	)

void complexity_add(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 + comp2; !usage: complexity_add(&comp1, comp2); comp2 keeps unchanged

Parameters

pcomp1	comp1
comp2	omp2

Definition at line 372 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp2) || COMPLEXITY_UNDEFINED_P(*pcomp1) )
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(*pcomp1) ) {
        *pcomp1 = complexity_dup(comp2);
    }
    else if ( !complexity_zero_p(comp2) ) {
        complexity_eval_(*pcomp1) = 
            newgen_Ppolynome(polynome_addition(complexity_eval(*pcomp1),
                                               complexity_eval(comp2)));
        complexity_stats_add(pcomp1, comp2);
    }
}

References complexity_dup(), complexity_eval, complexity_eval_, complexity_stats_add(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), newgen_Ppolynome, pips_internal_error, and polynome_addition().

Referenced by arguments_to_complexity(), block_to_complexity(), field_op_handler(), indices_to_complexity(), new_block_to_complexity(), plus_op_handler(), pvecteur_to_polynome(), range_to_complexity(), reference_to_complexity(), simplify_sc_to_complexity(), subscript_to_complexity(), syntax_to_complexity(), test_to_complexity(), unstructured_to_complexity(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_check()

bool complexity_check

(

complexity

comp

)

comp_util.c

comp_util.c

Parameters

comp

omp

Definition at line 96 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) )
        pips_internal_error("complexity undefined");
 
    if ( !complexity_zero_p(comp) ) {
        return (polynome_check(complexity_polynome(comp)));
    }
    return (true);
}

References complexity_polynome(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), pips_internal_error, and polynome_check().

Referenced by complexity_check_and_warn(), and good_complexity_assert().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_check_and_warn()

void complexity_check_and_warn	(	const char *	,
		complexity
	)

complexity_constant_p()

bool complexity_constant_p

(

complexity

comp

)

true if comp is constant.

Abort if undefined

Parameters

comp

omp

Definition at line 256 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) ) 
        pips_internal_error("undefined complexity");
 
    if ( complexity_zero_p(comp) ) 
        return (true);
    else 
        return (polynome_constant_p(complexity_eval(comp)));
}

References complexity_eval, COMPLEXITY_UNDEFINED_P, complexity_zero_p(), pips_internal_error, and polynome_constant_p().

Referenced by divide_op_handler(), loop_to_complexity(), and power_op_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_degree()

int complexity_degree

(

complexity

c

)

Definition at line 1167 of file comp_util.c.

{
    Ppolynome p = complexity_eval(c);
    int degree = polynome_max_degree(p);
 
    return degree;
}

References complexity_eval, and polynome_max_degree().

Referenced by loop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_div()

void complexity_div	(	complexity *	pcomp1,
		complexity	comp2
	)

void complexity_div(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 / comp2; !usage: complexity_div(&comp1, comp2);

polynome_rm(&(complexity_eval(*pcomp1)));

Parameters

pcomp1	comp1
comp2	omp2

Definition at line 445 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp2) || COMPLEXITY_UNDEFINED_P(*pcomp1) )
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(comp2) ) {
        pips_internal_error("complexity divider is zero");
    }
    else if ( !complexity_zero_p(*pcomp1) ) {
        Ppolynome ppdiv;
        ppdiv = polynome_div(complexity_eval(*pcomp1), complexity_eval(comp2));
/*      polynome_rm(&(complexity_eval(*pcomp1))); */
        complexity_eval_(*pcomp1) = newgen_Ppolynome(ppdiv);
        complexity_stats_add(pcomp1, comp2);
    }
}

References complexity_eval, complexity_eval_, complexity_stats_add(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), newgen_Ppolynome, pips_internal_error, and polynome_div().

Referenced by loop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_dump()

void complexity_dump

(

complexity

comp

)

Parameters

comp

omp

Definition at line 228 of file comp_util.c.

{
    complexity_fprint(stderr, comp, false, true);
}

References complexity_fprint().

Here is the call graph for this function:

complexity_dup()

complexity complexity_dup

(

complexity

comp

)

duplicates complexity comp

Parameters

comp

omp

Definition at line 131 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) ) 
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(comp) ) 
        return (make_zero_complexity());
    else {
        varcount   vc = complexity_varcount(comp);
        rangecount rc = complexity_rangecount(comp);
        ifcount    ic = complexity_ifcount(comp);
 
        varcount newvc = make_varcount(varcount_symbolic(vc), 
                                       varcount_guessed(vc),
                                       varcount_bounded(vc), 
                                       varcount_unknown(vc));
        rangecount newrc = make_rangecount(rangecount_profiled(rc), 
                                           rangecount_guessed(rc),
                                           rangecount_bounded(rc),
                                           rangecount_unknown(rc));
        ifcount newic = make_ifcount(ifcount_profiled(ic), 
                                     ifcount_computed(ic),
                                     ifcount_halfhalf(ic));
    
        Ppolynome ppdup = polynome_dup(complexity_polynome(comp));
        complexity compl = make_complexity(ppdup, newvc, newrc, newic);
 
        return(compl);
    }
}

References complexity_ifcount, complexity_polynome(), complexity_rangecount, COMPLEXITY_UNDEFINED_P, complexity_varcount, complexity_zero_p(), ifcount_computed, ifcount_halfhalf, ifcount_profiled, make_complexity(), make_ifcount(), make_rangecount(), make_varcount(), make_zero_complexity(), pips_internal_error, polynome_dup(), rangecount_bounded, rangecount_guessed, rangecount_profiled, rangecount_unknown, varcount_bounded, varcount_guessed, varcount_symbolic, and varcount_unknown.

Referenced by complexity_add(), complexity_stats_add(), complexity_sub(), final_statement_to_complexity_evaluation(), replace_formal_parameters_by_real_ones(), test_to_complexity(), and translate_complexity_from_local_to_current_name().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_float_add()

void complexity_float_add	(	complexity *	,
		double
	)

complexity_fprint()

void complexity_fprint	(	FILE *	fd,
		complexity	comp,
		bool	print_stats_p,
		bool	print_local_names_p
	)

Parameters

fd	d
comp	omp
print_stats_p	rint_stats_p
print_local_names_p	rint_local_names_p

Definition at line 217 of file comp_util.c.

{
    char *s = complexity_sprint(comp, print_stats_p, print_local_names_p);
 
    fprintf(fd, "%s\n", s);
    free(s);
}

References complexity_sprint(), fprintf(), and free().

Referenced by arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), cast_to_polynome(), complexity_dump(), complexity_var_subst(), controls_to_hash_table(), expression_to_complexity_polynome(), fetch_callees_complexities(), final_statement_to_complexity_evaluation(), fprint_statement_complexity(), loop_to_complexity(), prc(), range_to_complexity(), reference_to_complexity(), statement_to_complexity(), test_to_complexity(), unstructured_to_complexity(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_is_monomial_p()

bool complexity_is_monomial_p

(

complexity

c

)

Definition at line 1159 of file comp_util.c.

{
    Ppolynome p = complexity_eval(c);
    bool monomial_p = is_single_monome(p);
 
    return monomial_p;
}

References complexity_eval, and is_single_monome.

Referenced by loop_to_complexity().

Here is the caller graph for this function:

complexity_map_undefined_p()

bool complexity_map_undefined_p

(

void

)

complexity_mult()

void complexity_mult	(	complexity *	pcomp1,
		complexity	comp2
	)

void complexity_mult(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 * comp2; !usage: complexity_mult(&comp1, comp2);

(Ppolynome) complexity_eval(*pcomp1) = (Ppolynome) ppmult;

Parameters

pcomp1	comp1
comp2	omp2

Definition at line 418 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp2) || COMPLEXITY_UNDEFINED_P(*pcomp1) )
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(comp2) ) {
        complexity_rm(pcomp1);
        *pcomp1 = make_zero_complexity();
    }
    else if ( !complexity_zero_p(*pcomp1) ) {
        Ppolynome ppmult;
 
        ppmult = polynome_mult(complexity_eval(*pcomp1),
                               complexity_eval(comp2));
        complexity_eval_(*pcomp1) = 
            newgen_Ppolynome(polynome_free(complexity_eval(*pcomp1)));
        /* (Ppolynome) complexity_eval(*pcomp1) = (Ppolynome) ppmult; */
        complexity_eval_(*pcomp1) = newgen_Ppolynome(ppmult);
        complexity_stats_add(pcomp1, comp2);
    }
}

References complexity_eval, complexity_eval_, complexity_rm(), complexity_stats_add(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), make_zero_complexity(), newgen_Ppolynome, pips_internal_error, polynome_free(), and polynome_mult().

Referenced by complexity_sigma(), divide_op_handler(), multiply_op_handler(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_polynome()

Ppolynome complexity_polynome

(

complexity

comp

)

Because complexity is composed of two elements, we use this function to get the first element : polynome Usage : complexity_polynome(complexity comp) you will get a pointer to the polynome May 3, 91 lz.

Parameters

comp

omp

Definition at line 506 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) ) 
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(comp) ) 
        return (POLYNOME_NUL);
    else 
        return ((Ppolynome)complexity_eval(comp));
}

References complexity_eval, COMPLEXITY_UNDEFINED_P, complexity_zero_p(), pips_internal_error, and POLYNOME_NUL.

Referenced by block_to_complexity(), complexity_check(), complexity_dup(), complexity_sigma(), complexity_sprint(), complexity_var_subst(), do_computation_intensity(), final_statement_to_complexity_evaluation(), if_conv_init_statement(), loop_to_complexity(), power_op_handler(), task_time(), and translate_complexity_from_local_to_current_name().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_polynome_add()

void complexity_polynome_add	(	complexity *	pcomp,
		Ppolynome	pp
	)

Parameters

pcomp	comp
pp	p

Definition at line 463 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(*pcomp) ) 
        pips_internal_error("complexity undefined");
    else if ( POLYNOME_UNDEFINED_P(pp)  )
        pips_internal_error("polynome undefined");
    else {
        complexity_eval_(*pcomp) = 
            newgen_Ppolynome(polynome_addition(complexity_eval(*pcomp), pp));
    }
}

References complexity_eval, complexity_eval_, COMPLEXITY_UNDEFINED_P, newgen_Ppolynome, pips_internal_error, polynome_addition(), and POLYNOME_UNDEFINED_P.

Referenced by loop_to_complexity(), and pvecteur_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_rm()

void complexity_rm

(

complexity *

pcomp

)

remove complexity comp

Parameters

pcomp

comp

Definition at line 164 of file comp_util.c.

{
    if ( COMPLEXITY_UNDEFINED_P(*pcomp) )
        pips_internal_error("undefined complexity");
 
    if ( !complexity_zero_p(*pcomp) ) 
        free_complexity(*pcomp);
    *pcomp = make_zero_complexity();// complexity_undefined;
}

References COMPLEXITY_UNDEFINED_P, complexity_zero_p(), free_complexity(), make_zero_complexity(), and pips_internal_error.

Referenced by complexity_mult(), complexity_scalar_mult(), divide_op_handler(), field_op_handler(), indices_to_complexity(), loop_to_complexity(), minus_op_handler(), multiply_op_handler(), plus_op_handler(), power_op_handler(), range_to_complexity(), reference_to_complexity(), replace_formal_parameters_by_real_ones(), simplify_sc_to_complexity(), subscript_to_complexity(), syntax_to_complexity(), test_to_complexity(), and unary_minus_op_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_scalar_mult()

void complexity_scalar_mult	(	complexity *	,
		double
	)

complexity_sigma()

complexity complexity_sigma	(	complexity	comp,
		Variable	index,
		complexity	clower,
		complexity	cupper
	)

comp_math.c

"mathematical" operations on complexities

complexity complexity_sigma(comp, index, clower, cupper) complexity_var_subst(comp, var, compsubst) complexity polynome_to_new_complexity(pp) complexity complexity_dup(comp) void complexity_rm(pcomp) complexity make_single_var_complexity(float, var) bool complexity_constant_p(comp) float complexity_TCST(comp) void complexity_scalar_mult(pcomp, f) void complexity_float_add(pcomp, f) void complexity_stats_add(pcomp1, comp2) void complexity_add(pcomp1, comp2) void complexity_sub(pcomp1, comp2) void complexity_mult(pcomp1, comp2) void complexity_polynome_add(pcomp, pp) Ppolynome complexity_polynome(comp) complexity replace_formal_parameters_by_real_ones(comp, mod, args, precond) Modif: – entity_local_name is replaced by module_local_name. LZ 230993 complexity complexity_sigma(complexity comp, Variable index, complexity clower, cupper) return the integration of complexity comp when the index is running between clower and cupper. Based on the polynomial library routine polynome_sigma.

• comp is undefined => result undefined.
• comp is null => result is null whatever the bounds are.
• bound(s) is(are) undefined: if comp depends on the index, the result is undefined; else the result is comp * UNKNOWN_RANGE.
• everything is defined: the result is the integration of the respective polynomials.

FI: Too late to build a meaningful unknown range name!

tats

Parameters

comp	omp
index	ndex
clower	lower
cupper	upper

Definition at line 84 of file comp_math.c.

{
    complexity cresult = make_zero_complexity();
    Ppolynome ppsum;
    Ppolynome pplower = POLYNOME_NUL;
    Ppolynome ppupper = POLYNOME_NUL;
 
    if (COMPLEXITY_UNDEFINED_P(comp))
        pips_internal_error("complexity undefined");
 
    if (complexity_zero_p(comp))
        return (cresult);
    else if ( COMPLEXITY_UNDEFINED_P(clower) || 
             COMPLEXITY_UNDEFINED_P(cupper) ) {
        if ( polynome_contains_var(complexity_polynome(comp), 
                                   (Variable)index) )
            return (cresult);
        else {
            /* FI: Too late to build a meaningful unknown range name! */
            /*
            ppsum = make_polynome(1.0, UNKNOWN_RANGE, 1);
            */
            entity ur = make_new_scalar_variable_with_prefix
                (UNKNOWN_RANGE_NAME,
                 get_current_module_entity(),
                 MakeBasic(is_basic_int));
        AddEntityToCurrentModule(ur);
            ppsum = make_polynome(1.0, (Variable) ur, VALUE_ONE);
            cresult = polynome_to_new_complexity(ppsum); /*stats*/
            complexity_mult(&cresult, comp);
            
            polynome_rm(&ppsum);
            return(cresult);
        }
    }
    else {
        pplower = complexity_polynome(clower);
        ppupper = complexity_polynome(cupper);
        
        if (false) {
            fprintf(stderr, "summing ");
            prp(complexity_polynome(comp));
            fprintf(stderr, " %s running between ", 
                    module_local_name((entity)index));
            prp(pplower);
            fprintf(stderr, " and ");
            prp(ppupper);
            fprintf(stderr, "\n");
        }
        
        ppsum = polynome_sigma(complexity_polynome(comp),
                               (Variable) index,
                               pplower, ppupper);
        cresult = polynome_to_new_complexity(ppsum);
        complexity_stats_add(&cresult, comp);
        complexity_stats_add(&cresult, clower);
        complexity_stats_add(&cresult, cupper);
        
        polynome_rm(&ppsum);
        return(cresult);
    }
}

References AddEntityToCurrentModule(), complexity_mult(), complexity_polynome(), complexity_stats_add(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), fprintf(), get_current_module_entity(), is_basic_int, make_new_scalar_variable_with_prefix(), make_polynome(), make_zero_complexity(), MakeBasic(), module_local_name(), pips_internal_error, polynome_contains_var(), POLYNOME_NUL, polynome_rm(), polynome_sigma(), polynome_to_new_complexity(), prp(), UNKNOWN_RANGE_NAME, and VALUE_ONE.

Referenced by loop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_sprint()

char* complexity_sprint	(	complexity	comp,
		bool	print_stats_p,
		bool	print_local_names_p
	)

Parameters

comp	omp
print_stats_p	rint_stats_p
print_local_names_p	rint_local_names_p

Definition at line 175 of file comp_util.c.

{
 
    char *s=NULL;
 
    if ( COMPLEXITY_UNDEFINED_P(comp) )
        pips_internal_error("complexity undefined");
    else {
        varcount vc   = complexity_varcount(comp);
        rangecount rc = complexity_rangecount(comp);
        ifcount ic    = complexity_ifcount(comp);
 
        char * p = polynome_sprint(complexity_polynome(comp),
                (print_local_names_p ? variable_local_name 
                 : variable_name),
                is_inferior_pvarval);
 
        if ( print_stats_p ) {
            asprintf(&s,"[(var:%td/%td/%td/%td)"
                    " (rng:%td/%td/%td/%td)"
                    " (ifs:%td/%td/%td)]  %s",
                    varcount_symbolic(vc),
                    varcount_guessed(vc),
                    varcount_bounded(vc), 
                    varcount_unknown(vc),
                    rangecount_profiled(rc),
                    rangecount_guessed(rc),
                    rangecount_bounded(rc), 
                    rangecount_unknown(rc),
                    ifcount_profiled(ic), 
                    ifcount_computed(ic),
                    ifcount_halfhalf(ic),p);
            free(p);
        }
        else
            s=p;
    }
    return s;
}

References asprintf, complexity_ifcount, complexity_polynome(), complexity_rangecount, COMPLEXITY_UNDEFINED_P, complexity_varcount, free(), ifcount_computed, ifcount_halfhalf, ifcount_profiled, is_inferior_pvarval(), pips_internal_error, polynome_sprint(), rangecount_bounded, rangecount_guessed, rangecount_profiled, rangecount_unknown, varcount_bounded, varcount_guessed, varcount_symbolic, varcount_unknown, variable_local_name(), and variable_name().

Referenced by complexity_fprint(), task_complexity(), task_time_polynome(), text_complexity(), and text_summary_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_stats_add()

void complexity_stats_add	(	complexity *	pcomp1,
		complexity	comp2
	)

Add comp2's statistics to *pcomp1's comp2 keeps unchanged.

Parameters

pcomp1	comp1
comp2	omp2

Definition at line 323 of file comp_math.c.

{
    ifdebug (1) {
        (void) complexity_consistent_p(*pcomp1);
        (void) complexity_consistent_p(comp2);
    }
 
    if ( COMPLEXITY_UNDEFINED_P(comp2) || COMPLEXITY_UNDEFINED_P(*pcomp1) )
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(*pcomp1) ) {
        *pcomp1 = complexity_dup(comp2);
        complexity_eval_(*pcomp1) = 
            newgen_Ppolynome(polynome_free(complexity_eval(*pcomp1)));
    }
    else if ( !complexity_zero_p(comp2) ) {
        varcount   vc1 = complexity_varcount(*pcomp1);
        rangecount rc1 = complexity_rangecount(*pcomp1);
        ifcount    ic1 = complexity_ifcount(*pcomp1);
        varcount   vc2 = complexity_varcount(comp2);
        rangecount rc2 = complexity_rangecount(comp2);
        ifcount    ic2 = complexity_ifcount(comp2);
 
        varcount_symbolic(vc1) += varcount_symbolic(vc2);
        varcount_guessed(vc1) += varcount_guessed(vc2);
        varcount_bounded(vc1) += varcount_bounded(vc2);
        varcount_unknown(vc1) += varcount_unknown(vc2);
 
        rangecount_profiled(rc1) += rangecount_profiled(rc2);
        rangecount_guessed(rc1) += rangecount_guessed(rc2);
        rangecount_bounded(rc1) += rangecount_bounded(rc2);
        rangecount_unknown(rc1) += rangecount_unknown(rc2);
 
        ifcount_profiled(ic1) += ifcount_profiled(ic2);
        ifcount_computed(ic1) += ifcount_computed(ic2);
        ifcount_halfhalf(ic1) += ifcount_halfhalf(ic2);
    }
 
    ifdebug (1) {
        (void) complexity_consistent_p(*pcomp1);
    }
}    

References complexity_consistent_p(), complexity_dup(), complexity_eval, complexity_eval_, complexity_ifcount, complexity_rangecount, COMPLEXITY_UNDEFINED_P, complexity_varcount, complexity_zero_p(), ifcount_computed, ifcount_halfhalf, ifcount_profiled, ifdebug, newgen_Ppolynome, pips_internal_error, polynome_free(), rangecount_bounded, rangecount_guessed, rangecount_profiled, rangecount_unknown, varcount_bounded, varcount_guessed, varcount_symbolic, and varcount_unknown.

Referenced by complexity_add(), complexity_div(), complexity_mult(), complexity_sigma(), complexity_sub(), complexity_var_subst(), and loop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_sub()

void complexity_sub	(	complexity *	pcomp1,
		complexity	comp2
	)

void complexity_sub(complexity *pcomp1, comp2) performs *pcomp1 = *pcomp1 - comp2; !usage: complexity_sub(&comp1, comp2); comp2 keeps unchanged

Parameters

pcomp1	comp1
comp2	omp2

Definition at line 394 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp2) || COMPLEXITY_UNDEFINED_P(*pcomp1) )
        pips_internal_error("complexity undefined");
 
    if ( complexity_zero_p(*pcomp1) ) 
        *pcomp1 = complexity_dup(comp2);
    else if ( !complexity_zero_p(comp2) ) {
        complexity_eval_(comp2) = 
            newgen_Ppolynome(polynome_opposed(complexity_eval(comp2)));
        complexity_eval_(*pcomp1) = 
            newgen_Ppolynome(polynome_addition(complexity_eval(*pcomp1), 
                                               complexity_eval(comp2)));
        complexity_stats_add(pcomp1, comp2);
        complexity_eval_(comp2) = 
            newgen_Ppolynome(polynome_opposed(complexity_eval(comp2)));
    }
}

References complexity_dup(), complexity_eval, complexity_eval_, complexity_stats_add(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), newgen_Ppolynome, pips_internal_error, polynome_addition(), and polynome_opposed().

Referenced by minus_op_handler(), and unary_minus_op_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_TCST()

float complexity_TCST

(

complexity

comp

)

return the constant term of comp.

Abort if undefined

Parameters

comp

omp

Definition at line 288 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) )
        pips_internal_error("undefined complexity");
 
    if ( complexity_zero_p(comp) ) 
        return ((float) 0);
    else 
        return (polynome_TCST(complexity_eval(comp)));
}

References complexity_eval, COMPLEXITY_UNDEFINED_P, complexity_zero_p(), pips_internal_error, and polynome_TCST().

Referenced by divide_op_handler(), loop_to_complexity(), and power_op_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_unknown_p()

bool complexity_unknown_p

(

complexity

comp

)

true if comp is unknown.

Abort if undefined

FI: Management of unknown complexities, when polynomes are in fact used to represent the value of a variables or an expression, has to be revisited

Parameters

comp

omp

Definition at line 269 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) ) 
        pips_internal_error("undefined complexity");
 
    /* FI: Management of unknown complexities, when polynomes are in
       fact used to represent the value of a variables or an expression,
       has to be revisited */
    /*
    if ( polynome_contains_var((Ppolynome)complexity_eval(comp), 
                               UNKNOWN_RANGE) ) 
        return (true);
    else 
    */
        return (false);
}

References COMPLEXITY_UNDEFINED_P, and pips_internal_error.

Referenced by expression_to_complexity_polynome(), and loop_to_complexity().

Here is the caller graph for this function:

complexity_var_subst()

complexity complexity_var_subst	(	complexity	comp,
		Variable	var,
		complexity	compsubst
	)

complexity complexity_var_subst(comp, var, compsubst) replaces every occurrence of variable var in complexity comp by the polynomial of complexity compsubst.

The statistics of compsubst are added to those of comp.

substitutes

Parameters

comp	omp
var	ar
compsubst	ompsubst

Definition at line 155 of file comp_math.c.

{
    Ppolynome pp, ppsubst, ppresult;
    complexity cresult = make_zero_complexity();
 
    if (COMPLEXITY_UNDEFINED_P(comp) || COMPLEXITY_UNDEFINED_P(compsubst)) 
        pips_internal_error("complexity undefined");
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr,"complexity_var_subst, variable name=%s\n",
                        variable_name(var) );
    }
 
    if (complexity_zero_p(comp)) 
        return (cresult);
    else {
        pp = complexity_polynome(comp);
        ppsubst = complexity_polynome(compsubst);
 
        ppresult = polynome_var_subst(pp, var, ppsubst); /* substitutes */
 
        cresult = polynome_to_new_complexity(ppresult);
        complexity_stats_add(&cresult, compsubst);
 
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            (void) complexity_consistent_p(cresult);
            fprintf(stderr,"complexity_var_subst, comp    is ");
            complexity_fprint(stderr, comp, false, true);
            fprintf(stderr,"complexity_var_subst, compsubst is ");
            complexity_fprint(stderr, compsubst, false, true);
            fprintf(stderr,"complexity_var_subst, cresult is ");
            complexity_fprint(stderr, cresult, false, true);
        }
    }
 
    return(cresult);
}

References complexity_consistent_p(), complexity_fprint(), complexity_polynome(), complexity_stats_add(), COMPLEXITY_UNDEFINED_P, complexity_zero_p(), fprintf(), get_bool_property(), make_zero_complexity(), pips_internal_error, polynome_to_new_complexity(), polynome_var_subst(), and variable_name().

Referenced by block_to_complexity(), new_block_to_complexity(), replace_formal_parameters_by_real_ones(), and translate_complexity_from_local_to_current_name().

Here is the call graph for this function:

Here is the caller graph for this function:

complexity_zero_p()

bool complexity_zero_p

(

complexity

comp

)

zero complexity check.

Abort if undefined

Parameters

comp

omp

Definition at line 244 of file comp_math.c.

{
    if ( COMPLEXITY_UNDEFINED_P(comp) ) 
        pips_internal_error("undefined complexity");
 
    if ( POLYNOME_NUL_P((Ppolynome)complexity_eval(comp)) )
        return (true);
    return (false);
}

References complexity_eval, COMPLEXITY_UNDEFINED_P, pips_internal_error, and POLYNOME_NUL_P.

Referenced by complexity_add(), complexity_check(), complexity_check_and_warn(), complexity_constant_p(), complexity_div(), complexity_dup(), complexity_float_add(), complexity_mult(), complexity_polynome(), complexity_rm(), complexity_scalar_mult(), complexity_sigma(), complexity_stats_add(), complexity_sub(), complexity_TCST(), complexity_var_subst(), evaluate_var_to_complexity(), pvecteur_to_polynome(), task_complexity(), task_time_polynome(), and test_to_complexity().

Here is the caller graph for this function:

constant_entity_to_float()

float constant_entity_to_float

(

entity

e

)

Return if possible the value of e in a float.

it is supposed to be an int or a float.

Definition at line 664 of file comp_util.c.

{
    const char *cste = module_local_name(e);
    basic b = entity_basic(e);
    float f;
 
    if (basic_int_p(b) || basic_float_p(b)) {
        sscanf(cste, "%f", &f);
        return (f);
    }
    else {
        user_warning("constant_entity_to_float",
                     "Basic tag:%d, not 4->9, (entity %s)\n",basic_tag(b),cste);
        return (0.0);
    }
}

References basic_float_p, basic_int_p, basic_tag, entity_basic(), f(), module_local_name(), and user_warning.

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

control_element_position_in_control_array()

int control_element_position_in_control_array	(	control	,
		control	[],
		int
	)

controls_to_hash_table()

void controls_to_hash_table	(	control	,
		int *	,
		control	[],
		hash_table	,
		transformer	,
		list
	)

delete_statement_complexity()

void delete_statement_complexity

(

statement

)

divide_op_handler()

complexity divide_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 560 of file comp_expr_to_pnome.c.

{
    float denominateur;
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(CDR(args))),
                                           precond, effects_list, DONT_KEEP_SYMBOLS,
                                           -maximize);
    if (complexity_constant_p(c2)) {
        denominateur = complexity_TCST(c2);
        if (denominateur == 0)
            user_error("divide_op_handler", "division by zero\n");
        else
            complexity_mult(&c1, make_constant_complexity(1.0/denominateur));
    }
    else {
        complexity_rm(&c1);
    }
 
    complexity_rm(&c2);
    return (c1);
}

References CAR, CDR, complexity_constant_p(), complexity_mult(), complexity_rm(), complexity_TCST(), DONT_KEEP_SYMBOLS, EXPRESSION, expression_to_complexity_polynome(), make_constant_complexity(), and user_error.

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_list_reverse()

list entity_list_reverse

(

list

l

)

Definition at line 757 of file comp_util.c.

{
    entity e;
 
    if ((l == NIL) || (l->cdr == NIL)) 
        return l;
    e = ENTITY(CAR(l));
    return (CONS(ENTITY, e, entity_list_reverse(l->cdr)));
}

References CAR, CONS, ENTITY, and NIL.

evaluate_var_to_complexity()

complexity evaluate_var_to_complexity	(	entity	,
		transformer	,
		list	,
		int
	)

expression_to_complexity()

complexity expression_to_complexity	(	expression	expr,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

2nd element of call –arguments

2nd element of reference –indices

Parameters

expr	xpr
pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 838 of file comp_scan.c.

{
    syntax s = expression_syntax(expr);
    complexity comp = make_zero_complexity();// complexity_undefined;
 
    trace_on("expression");
 
    if ( s != syntax_undefined )
        comp = syntax_to_complexity(s, pbasic, precond, effects_list);
    else
        pips_internal_error("syntax undefined");
 
    complexity_check_and_warn("expression_to_complexity", comp);
 
    trace_off();
    return(comp);
}

References complexity_check_and_warn(), expression_syntax, make_zero_complexity(), pips_internal_error, syntax_to_complexity(), syntax_undefined, trace_off(), and trace_on().

Referenced by arguments_to_complexity(), indices_to_complexity(), instruction_to_complexity(), range_to_complexity(), subscript_to_complexity(), syntax_to_complexity(), test_to_complexity(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_complexity_polynome()

complexity expression_to_complexity_polynome	(	expression	expr,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Entry point routine of this file:

complexity expression_to_complexity_polynome(expression expr, transformer precond, list effects_list, bool keep_symbols, int maximize) return the polynomial associated to the expression expr, or POLYNOME_UNDEFINED if it's not a polynome. or POLYNOME_NULL if it's a 0 complexity. If keep_symbols is false, we force evaluation of variables. If they can't be evaluated, they enter the polynomial, but they are replaced by the pseudo-variable UNKNOWN_VARIABLE, except when they appear in a loop range: in that case, the whole range is replaced by UNKNOWN_RANGE. The int maximize lets us use the mins and maxs of preconditions system, to compute a WORST-CASE complexity for the upper bound , maximize is 1 for the lower bound and increment, maximize is -1 (when the precondition doesn't give an exact value)

effects_list is added on 10 Nov 92 to pass the effects which can be used to determine the "must-be-written" effects to delay the variable evaluation. LZ 10 Nov 92

FI:

• better symbol generation for unknown complexities

The following line is merely for debugging

Parameters

expr	xpr
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 118 of file comp_expr_to_pnome.c.

{
    normalized no = NORMALIZE_EXPRESSION(expr);
    syntax sy = expression_syntax(expr);
    complexity comp = make_zero_complexity();
 
    trace_on("expression -> pnome");
 
    if ( expr == expression_undefined ) {
        pips_internal_error("undefined expression");
    }
    if ( sy == syntax_undefined ) {
        pips_internal_error("wrong expression");
    }
 
    if ( normalized_linear_p(no) ) {
        comp =  normalized_to_polynome(no, precond, effects_list,
                                       keep_symbols, maximize);
    }
    else {
        comp = syntax_to_polynome(sy, precond, effects_list, keep_symbols, maximize);
    }
 
    if ( complexity_unknown_p(comp) ) {
        pips_internal_error("Better unknown value name generation required!");
        /*
        return(make_single_var_complexity(1.0,UNKNOWN_RANGE));
        */
        return complexity_undefined;
    }
 
    /* The following line is merely for debugging */
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "expr->pnome ");
        complexity_fprint(stderr, comp, true, true);
    }
 
    trace_off();
    return (comp);
}

References complexity_fprint(), complexity_undefined, complexity_unknown_p(), expression_syntax, expression_undefined, fprintf(), get_bool_property(), make_zero_complexity(), NORMALIZE_EXPRESSION, normalized_linear_p, normalized_to_polynome(), pips_internal_error, syntax_to_polynome(), syntax_undefined, trace_off(), and trace_on().

Referenced by cast_to_polynome(), divide_op_handler(), field_op_handler(), loop_to_complexity(), minus_op_handler(), multiply_op_handler(), plus_op_handler(), power_op_handler(), replace_formal_parameters_by_real_ones(), unary_minus_op_handler(), unary_plus_op_handler(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_callees_complexities()

hash_table fetch_callees_complexities

(

char *

module_name

)

translate the local name to current module name. LZ 5 Feb.93

i.e. SUB:M -> MAIN:M

FI: this seems to be wrong in general because the formal parameter and actual argument are assumed to have the same name; see DemoStd/q and variables IM/IMM; 3 March 1994

Parameters

module_name

odule_name

Definition at line 821 of file comp_util.c.

{
    hash_table hash_callees_comp = hash_table_make(hash_pointer, 0);
    callees cl;
    list callees_list;
    complexity callee_comp;
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching callees complexities ...\n");
    }
 
    cl = (callees)db_get_memory_resource(DBR_CALLEES, module_name, true);
    callees_list = callees_callees(cl);
 
    if ( callees_list == NIL ) { 
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr, "Module %s has no callee! Done\n", module_name);
        }
        return(hash_callees_comp);
    }
 
    MAPL(pc, {
        string callee_name = STRING(CAR(pc));
        entity callee = module_name_to_entity(callee_name);
        type t = entity_type(callee);
 
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr, "%s has callee %s!\n",module_name,callee_name);
        }
        pips_assert("call_to_complexity",
                    type_functional_p(t) || type_void_p(t));
 
        if (value_code_p(entity_initial(callee))) {
            complexity new_comp;
            callee_comp = (complexity)
                db_get_memory_resource(DBR_SUMMARY_COMPLEXITY, 
                                       (char *) callee_name,
                                       true);
 
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "fetched complexity for callee %s",
                                 callee_name);
                fprintf(stderr, " of module %s:\n", module_name);
                complexity_fprint(stderr, callee_comp, 
                                          DO_PRINT_STATS, 
                                          ! PRINT_LOCAL_NAMES);
            }
 
            debug(5,"fetch_callees_complexities","callee_name %s\n",callee_name);
 
            /* translate the local name to current module name. LZ 5 Feb.93 */
            /* i.e. SUB:M -> MAIN:M */
            /* FI: this seems to be wrong in general because the 
             * formal parameter and actual argument are assumed to
             * have the same name; see DemoStd/q and variables IM/IMM;
             * 3 March 1994
             */
            new_comp = translate_complexity_from_local_to_current_name(callee_comp, 
                                                            callee_name,module_name);
 
            hash_put(hash_callees_comp, (char *)callee, (char *)new_comp);
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "translated complexity for callee %s",
                                 callee_name);
                fprintf(stderr, " of module %s:\n", module_name);
                complexity_fprint(stderr, new_comp, 
                                          DO_PRINT_STATS, 
                                          ! PRINT_LOCAL_NAMES);
            }
        }
    }, callees_list );
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching callees complexities ... done\n");
    }
 
    return(hash_callees_comp);
}

References callee, callees_callees, CAR, complexity_fprint(), db_get_memory_resource(), debug(), DO_PRINT_STATS, entity_initial, entity_type, fprintf(), get_bool_property(), hash_pointer, hash_put(), hash_table_make(), MAPL, module_name(), module_name_to_entity(), NIL, pips_assert, PRINT_LOCAL_NAMES, STRING, translate_complexity_from_local_to_current_name(), type_functional_p, type_void_p, and value_code_p.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

fetch_complexity_parameters()

hash_table fetch_complexity_parameters

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 901 of file comp_util.c.

{
    hash_table hash_comp_params = hash_table_make(hash_pointer, 0);
    char *parameters = strdup(get_string_property("COMPLEXITY_PARAMETERS"));
    char *sep_chars = strdup(", ");
    char *token = (char*) malloc(30);
    entity e;
 
    hash_warn_on_redefinition();
   
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching complexity parameters for module %s:\n",
                module_name);
    }
 
    token = strtok(parameters, sep_chars);
 
    while (token != NULL) {
        e = gen_find_tabulated(concatenate(module_name,
                                           MODULE_SEP_STRING,
                                           token,
                                           (char *) NULL),
                               entity_domain);
        if (e != entity_undefined) {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "{\t Defined entity  %s }\n", entity_name(e));
            }
            hash_put(hash_comp_params,(char *)e,HASH_USER_VARIABLE);
        }
        else {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "{\t Undefined token  %s }\n", token);
            }
        }
        token = strtok(NULL, sep_chars);
    }
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Fetching complexity parameters: ...done.\n");
    }
 
    return(hash_comp_params);
}

References concatenate(), entity_domain, entity_name, entity_undefined, fprintf(), gen_find_tabulated(), get_bool_property(), get_string_property(), hash_pointer, hash_put(), hash_table_make(), HASH_USER_VARIABLE, hash_warn_on_redefinition(), malloc(), module_name(), MODULE_SEP_STRING, and strdup().

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

field_op_handler()

complexity field_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 512 of file comp_expr_to_pnome.c.

                                                            {
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(CDR(args))),
                                           precond, effects_list, keep_symbols,
                                           maximize);
 
    complexity_add(&c1, c2);
    complexity_rm(&c2);
 
    return (c1);
}

References CAR, CDR, complexity_add(), complexity_rm(), EXPRESSION, and expression_to_complexity_polynome().

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

final_statement_to_complexity_evaluation()

complexity final_statement_to_complexity_evaluation	(	complexity	comp,
		transformer	precond,
		list	effects_list
	)

Parameters

comp	omp
precond	recond
effects_list	ffects_list

Definition at line 1052 of file comp_util.c.

{
    complexity final_comp = complexity_dup(comp);
    Ppolynome pp = complexity_polynome(comp);
    Pbase pb = vect_dup(polynome_used_var(pp, default_is_inferior_pvarval));
 
 
    fprintf(stderr, "Final evaluation\n");
 
    for ( ; !VECTEUR_NUL_P(pb); pb = pb->succ) {
        bool mustbewritten;
        char *var = variable_local_name(pb->var);
 
        fprintf(stderr, "Variable is %s\n", var);
 
        mustbewritten = is_must_be_written_var(effects_list, var);
 
        if ( mustbewritten ) {
            complexity compsubst;
            fprintf(stderr, "YES once\n");
            compsubst = evaluate_var_to_complexity((entity)pb->var, 
                                                   precond, 
                                                   effects_list, 1);
            complexity_fprint( stderr, compsubst, false, false);
/*
 
            final_comp = complexity_var_subst(comp, pb->var, compsubst);
*/
        }
        comp = complexity_dup(final_comp);
    }
 
    complexity_fprint( stderr, final_comp, false, false);
 
    return ( final_comp );
}

References complexity_dup(), complexity_fprint(), complexity_polynome(), default_is_inferior_pvarval(), evaluate_var_to_complexity(), fprintf(), is_must_be_written_var(), polynome_used_var(), Svecteur::succ, Svecteur::var, variable_local_name(), vect_dup(), and VECTEUR_NUL_P.

Here is the call graph for this function:

float_matrice_inversion()

void float_matrice_inversion	(	float *	a,
		int	n,
		int *	indx,
		int *	pd
	)

set up identity matrix

Parameters

indx	ndx
pd	d

Definition at line 198 of file comp_matrice.c.

{
    int i,j;
    float *y = (float *) malloc(sizeof(float) * n * n);
 
    /* set up identity matrix */
    for (i=0; i<n; i++ ) {
        for ( j=0; j<n; j++ )
            Y(i,j) = 0.0;
        Y(i,i) = 1.0;
    }
                
    lu_decomposition(a, n, indx, pd);
 
    for ( j=0; j<n; j++ ) {
        lu_back_substitution(a, n, indx, &(Y(j,0)) );
    }
    for ( j=0; j<n; j++ )
        for ( i=0; i<n; i++ )
            A(i,j) = Y(j,i);
}

References A, lu_back_substitution(), lu_decomposition(), malloc(), and Y.

Referenced by unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

fp_complexities()

bool fp_complexities

(

const

string

)

Parameters

string

odule_name

Definition at line 89 of file comp_scan.c.

{
    bool success = true;
 
    //set_string_property("COMPLEXITY_COST_TABLE", "fp_1");
    success = any_complexities(module_name);
 
    return success;
}

References any_complexities(), and module_name().

Here is the call graph for this function:

fprint_cost_table()

void fprint_cost_table

(

FILE *

fd

)

Parameters

fd

d

Definition at line 481 of file comp_util.c.

{
    struct intrinsic_cost_rec *p = intrinsic_cost_table;
    bool skip_one_line = false;
    
    fprintf(fd, "\nIntrinsic cost table:\n\n");
    fprintf(fd, "        Intrinsic name        int    float   double   complex   dcomplex\n");
    fprintf(fd, "------------------------------------------------------------------------\n");
            
    for(; p->name != NULL ;p++) {
        if (1 ||(p->int_cost      != 0) ||
            (p->float_cost    != 0) ||
            (p->double_cost   != 0) ||
            (p->complex_cost  != 0) ||
            (p->dcomplex_cost != 0)) {
            if (skip_one_line) {
                fprintf(fd, "%25s|\n", "");
                skip_one_line = false;
            }
            fprintf(fd, "%22.21s   |%6td %6td %7td %8td %8td\n",
                    p->name, p->int_cost, p->float_cost,
                    p->double_cost, p->complex_cost, p->dcomplex_cost);
        }
        else
            skip_one_line = true;
    }
    fprintf(fd, "\n");
}

References intrinsic_cost_rec::complex_cost, intrinsic_cost_rec::dcomplex_cost, intrinsic_cost_rec::double_cost, intrinsic_cost_rec::float_cost, fprintf(), intrinsic_cost_rec::int_cost, intrinsic_cost_table, and intrinsic_cost_rec::name.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

fprint_statement_complexity()

void fprint_statement_complexity	(	entity	module,
		statement	stat,
		hash_table	hash_statement_to_complexity
	)

Parameters

module	odule
stat	tat
hash_statement_to_complexity	ash_statement_to_complexity

Definition at line 253 of file comp_util.c.

{
  text t = Text_Statement(module, 0, stat);
    complexity comp;
 
    comp = ((complexity) hash_get(hash_statement_to_complexity,(char *)stat));
    if (COMPLEXITY_UNDEFINED_P(comp))
        pips_internal_error("undefined complexity");
    else {
        fprintf(stderr, "C -- ");
        complexity_fprint(stderr, comp, DO_PRINT_STATS, PRINT_LOCAL_NAMES);
    }
    print_text(stderr, t);
}

References complexity_fprint(), COMPLEXITY_UNDEFINED_P, DO_PRINT_STATS, fprintf(), hash_get(), module, pips_internal_error, PRINT_LOCAL_NAMES, print_text(), and Text_Statement().

Here is the call graph for this function:

free_callees_complexities()

hash_table free_callees_complexities

(

hash_table

h

)

Modified copies of the summary complexities are stored

Definition at line 812 of file comp_util.c.

{
    /* Modified copies of the summary complexities are stored */
    hash_table_clear(h);
    hash_table_free(h);
 
    return hash_table_undefined;
}

References hash_table_clear(), hash_table_free(), and hash_table_undefined.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

free_complexity_map()

void free_complexity_map

(

void

)

get_complexity_map()

statement_mapping get_complexity_map

(

void

)

Referenced by any_complexities().

Here is the caller graph for this function:

good_complexity_assert()

void good_complexity_assert	(	string	,
		complexity
	)

goto_to_complexity()

complexity goto_to_complexity	(	statement	,
		transformer	,
		list
	)

indices_to_complexity()

complexity indices_to_complexity	(	list	exprlist,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

2nd element of reference

exactly the same with arguments_to_complexity I add this function in order to make the structure clearer Apr. 15,91

Parameters

exprlist	xprlist
pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 1057 of file comp_scan.c.

{
    complexity comp = make_zero_complexity();
    basic ibasic = MAKE_INT_BASIC;
 
    trace_on("indices");
 
    *pbasic = MAKE_INT_BASIC;
 
    MAPL (pa, {
        expression e = EXPRESSION(CAR(pa));
        complexity ctmp = expression_to_complexity(e, &ibasic, precond, effects_list);
        complexity_add(&comp, ctmp);
        complexity_rm(&ctmp);
        
        if (is_inferior_basic(*pbasic, ibasic)) {
            free_basic(*pbasic);
            *pbasic = simple_basic_dup(ibasic);
        }
    },exprlist);
 
    complexity_check_and_warn("indices_to_complexity", comp);    
    
    trace_off();
    return(comp);
}

References CAR, complexity_add(), complexity_check_and_warn(), complexity_rm(), EXPRESSION, expression_to_complexity(), free_basic(), is_inferior_basic(), MAKE_INT_BASIC, make_zero_complexity(), MAPL, simple_basic_dup(), trace_off(), and trace_on().

Referenced by reference_to_complexity(), and subscript_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

init_cost_table()

void init_cost_table

(

void

)

Completes the intrinsic cost table with the costs read from the files specified in the "COMPLEXITY_COST_TABLE" string property See properties.rc and ~pips/Pips/pipsrc.csh for more information.

L. ZHOU 13/03/91

COST_DATA are names of five data files

Definition at line 519 of file comp_util.c.

{
    char *token, *comma, *filename ;
    float file_factor;
 
    char *cost_data = strdup(COST_DATA);
    char *tmp=NULL;
 
        for(token = strtok(cost_data, " "); (token != NULL);token = strtok(NULL, " ")) {
                comma = strchr(token, ',');
 
                if (comma == NULL) {
                        tmp=strdup(token);
                        file_factor = 1.0;
                }
                else {
                        int ii = comma - token;
                        tmp=strndup( token, ii);
                        sscanf(++comma, "%f", &file_factor);
                }
 
 
                filename = strdup(concatenate( COMPLEXITY_COST_TABLES "/", get_string_property("COMPLEXITY_COST_TABLE"), "/", tmp, NULL));
 
                debug(5,"init_cost_table","file_factor is %f\n", file_factor);
                debug(1,"init_cost_table","cost file is %s\n",filename);
 
                load_cost_file(fopen_config(filename,NULL,"PIPS_COSTDIR"), file_factor);
                free(tmp);
                free(filename);
        }
 
}

References concatenate(), COST_DATA, debug(), fopen_config(), free(), get_string_property(), load_cost_file(), strdup(), and strndup().

Referenced by any_complexities(), generic_print_xml_application(), and print_xml_code().

Here is the call graph for this function:

Here is the caller graph for this function:

instruction_to_complexity()

complexity instruction_to_complexity	(	instruction	instr,
		transformer	precond,
		list	effects_list
	)

The only element available of the statement.

dummy parameter

dummy parameter

Parameters

instr	nstr
precond	recond
effects_list	ffects_list

Definition at line 275 of file comp_scan.c.

{
  complexity comp = make_zero_complexity();// complexity_undefined;
 
    trace_on("instruction");
 
    switch (instruction_tag(instr)) {
    case is_instruction_block:
        comp = block_to_complexity(instruction_block(instr), precond, effects_list);
        break;
    case is_instruction_test:
        comp = test_to_complexity(instruction_test(instr), precond, effects_list);
        break;
    case is_instruction_loop:
        comp = loop_to_complexity(instruction_loop(instr), precond, effects_list);
        break;
    case is_instruction_whileloop:
        comp= whileloop_to_complexity(instruction_whileloop(instr), precond, effects_list);
        break;
    case is_instruction_goto:
        comp = goto_to_complexity(instruction_goto(instr), precond, effects_list);
        break;
    case is_instruction_call: {
        basic callbasic = MAKE_INT_BASIC;          /* dummy parameter */
        comp = call_to_complexity(instruction_call(instr),
                                  &callbasic, precond, effects_list);
        break;
    }
    case is_instruction_unstructured:
        comp = unstructured_to_complexity(instruction_unstructured(instr),
                                          precond, effects_list);
        break;
    case is_instruction_expression: { // copied from is_instruction_call
        basic callbasic = MAKE_INT_BASIC;          /* dummy parameter */
        comp = expression_to_complexity(instruction_expression(instr),
                                        &callbasic,
                                        precond, effects_list);
        break;
    }
    default:
        pips_internal_error("instruction tag %d isn't in 14->19.",
                   (int) instruction_tag(instr));
    }
    complexity_check_and_warn("instruction_to_complexity", comp);
 
    trace_off();
    return(comp);
}

References block_to_complexity(), call_to_complexity(), complexity_check_and_warn(), expression_to_complexity(), goto_to_complexity(), instruction_block, instruction_call, instruction_expression, instruction_goto, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_block, is_instruction_call, is_instruction_expression, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, loop_to_complexity(), MAKE_INT_BASIC, make_zero_complexity(), pips_internal_error, test_to_complexity(), trace_off(), trace_on(), unstructured_to_complexity(), and whileloop_to_complexity().

Referenced by statement_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

intrinsic_cost()

int intrinsic_cost	(	const char *	,
		basic *
	)

is_inferior_pvarval()

int is_inferior_pvarval	(	Pvecteur *	pvarval1,
		Pvecteur *	pvarval2
	)

Parameters

pvarval1	varval1
pvarval2	varval2

Definition at line 149 of file polynome_ri.c.

{
  int is_inferior;
 
  if (term_cst(*pvarval1))
    is_inferior = -1;
  else if(term_cst(*pvarval2))
    is_inferior = 1;
  else {
    // FI: should be entity_user_name...
    is_inferior = strcmp(variable_local_name(vecteur_var(*pvarval1)),
                         variable_local_name(vecteur_var(*pvarval2)));
  }
 
  // FI: Make sure that you do not return 0 for two different entities
  if(is_inferior==0 && vecteur_var(*pvarval1)!=vecteur_var(*pvarval2)) {
    is_inferior = strcmp(entity_name((entity)vecteur_var(*pvarval1)),
                         entity_name((entity)vecteur_var(*pvarval2)));
  }
 
  return is_inferior;
}

References entity_name, term_cst, variable_local_name(), and vecteur_var.

Referenced by complexity_sprint(), prp(), and translate_complexity_from_local_to_current_name().

Here is the call graph for this function:

Here is the caller graph for this function:

is_inferior_var()

bool is_inferior_var	(	Variable	var1,
		Variable	var2
	)

Parameters

var1	ar1
var2	ar2

Definition at line 118 of file polynome_ri.c.

{
    bool is_inferior = true;
    
    if (var1 == TCST)
        is_inferior = true;
    else if(var2 == TCST)
        is_inferior = false;
    else
        is_inferior = (strcmp(variable_local_name(var1), 
                             variable_local_name(var2)) <= 0 );
 
    return is_inferior; 
}

References TCST, and variable_local_name().

Referenced by is_inferior_monome(), polynome_fprint(), polynome_sort(), polynome_sprint(), and polynome_used_var().

Here is the call graph for this function:

Here is the caller graph for this function:

is_inferior_varval()

int is_inferior_varval	(	Pvecteur	varval1,
		Pvecteur	varval2
	)

Parameters

varval1	arval1
varval2	arval2

Definition at line 134 of file polynome_ri.c.

{
  int is_inferior;
 
  if (term_cst(varval1))
    is_inferior = 1;
  else if(term_cst(varval2))
    is_inferior = -1;
  else
    is_inferior = - strcmp(variable_local_name(vecteur_var(varval1)),
                           variable_local_name(vecteur_var(varval2)));
 
  return is_inferior;
}

References term_cst, variable_local_name(), and vecteur_var.

Here is the call graph for this function:

is_linear_unstructured()

bool is_linear_unstructured

(

unstructured

unstr

)

return true if unstr is simply a linear string of controls

Parameters

unstr

nstr

Definition at line 738 of file comp_util.c.

{
    control current = unstructured_control(unstr);
    control exit = unstructured_exit(unstr);
 
    while (current != exit) {
        list succs = control_successors(current);
 
        if (succs == NIL)
            pips_internal_error("control != exit one,it has no successor");
        if (CDR(succs) != NIL) 
            return (false);
        current = CONTROL(CAR(succs));
    }
 
    return(true);
}

References CAR, CDR, CONTROL, control_successors, current, exit, NIL, pips_internal_error, unstructured_control, and unstructured_exit.

is_must_be_written_var()

bool is_must_be_written_var	(	list	effects_list,
		char *	var_name
	)

fprintf(stderr, "is_must_be_written_var for entity %s\n", module_local_name(e) );

Parameters

effects_list	ffects_list
var_name	ar_name

Definition at line 1014 of file comp_util.c.

{
    MAPL(ce, { 
        effect eff = EFFECT(CAR(ce));
 
        if(eff == effect_undefined)
            pips_internal_error("unexpected effect undefined");
 
        if ( action_write_p(effect_action(eff)) 
            && approximation_exact_p(effect_approximation(eff)) ) {
            reference r = effect_any_reference(eff);
            entity e = reference_variable(r);
/*          
            fprintf(stderr, "is_must_be_written_var for entity %s\n", 
                    module_local_name(e) );
*/
            if ( strcmp(module_local_name(e), var_name) == 0 ) {
                return (true);
            }
        }
/*
        else {
            fprintf(stderr, "is_must_be_written_var for NOT entity %s\n", 
                    module_local_name(reference_variable(effect_any_reference(eff))) );
        }
*/
    },effects_list);
 
    return (false);
}

References action_write_p, approximation_exact_p, CAR, EFFECT, effect_action, effect_any_reference, effect_approximation, effect_undefined, MAPL, module_local_name(), pips_internal_error, and reference_variable.

Referenced by final_statement_to_complexity_evaluation().

Here is the call graph for this function:

Here is the caller graph for this function:

list_ith_element()

list list_ith_element	(	list	thelist,
		int	ith
	)

return a pointer to the (i)th element of the list if i = 1, the pointer doesn't change at all.

Parameters

thelist	helist
ith	th

Definition at line 579 of file comp_math.c.

{
    for( ; --ith > 0; thelist = CDR(thelist) ) {
        pips_assert("list_ith_element", thelist != NIL);
    }
 
    return (thelist);
}

References CDR, NIL, and pips_assert.

load_cost_file()

void load_cost_file	(	FILE *	,
		double
	)

load_statement_complexity()

complexity load_statement_complexity

(

statement

)

Referenced by do_computation_intensity(), if_conv_init_statement(), summary_complexity(), task_complexity(), task_time(), task_time_polynome(), and text_complexity().

Here is the caller graph for this function:

local_name_to_variable()

Variable local_name_to_variable

(

char *

name

)

Parameters

name

ame

Definition at line 194 of file polynome_ri.c.

{
    string s = make_entity_fullname("TOP-LEVEL", name);
 
    if (strcmp(name, TCST_NAME)==0) 
        return(TCST);
    /*
    else if (strcmp(name, UNKNOWN_VARIABLE_NAME) == 0) 
        return (UNKNOWN_VARIABLE);
    else if (strcmp(name, UNKNOWN_RANGE_NAME) == 0) 
        return (UNKNOWN_RANGE);
        */
    else {
        entity e = gen_find_tabulated(s, entity_domain);
        if (e != entity_undefined) 
            return ((Variable) e);
        else {
            user_warning("local_name_to_variable",
                         "entity '%s' not found:return chunk_undefined\n", name);
            return((Variable) chunk_undefined);
        }
    }
}

References chunk_undefined, entity_domain, entity_undefined, gen_find_tabulated(), make_entity_fullname(), TCST, TCST_NAME, and user_warning.

Here is the call graph for this function:

loop_to_complexity()

complexity loop_to_complexity	(	loop	loop_instr,
		transformer	precond,
		list	effects_list
	)

3rd element of instruction

FI: Lei chose to allocate the UL and UU entities in the current module... Maybe, we are ready fo some dynamic profiling...

string mod_name = entity_module_name(ll);

if the statement were still reachable, we could try to use the statement nunber...

In order to get rid of at-sign, add 1 , LZ 010492

tell callees that they mustn't try to evaluate the loop index

cioh cboh are derived from overhead file "overhead" LZ, 280993

zero iteration for sure

at least one iteration

maybe some iteration

an intermediate test based on preconditions would give better result with affine loop bounds

Parameters

loop_instr	oop_instr
precond	recond
effects_list	ffects_list

Definition at line 460 of file comp_scan.c.

{
    entity ll = loop_label (loop_instr);
    entity index = loop_index(loop_instr);
    range rng = loop_range(loop_instr);
    statement s = loop_body(loop_instr);
    execution ex = loop_execution(loop_instr);
    complexity comp, cbody, crange, clower, cupper, cincr, cioh, cboh;
    string sl,su,si;
    /* FI: Lei chose to allocate the UL and UU entities in the current
       module... Maybe, we are ready fo some dynamic profiling... */
    /* string mod_name = entity_module_name(ll); */
    basic ibioh = MAKE_INT_BASIC; 
    basic ibboh = MAKE_INT_BASIC;
 
    trace_on("loop %s label %s",entity_name(index),
                                entity_name(loop_label(loop_instr)));
 
    if ( empty_global_label_p(entity_name(ll)) ) {
        /* if the statement were still reachable, we could try to use the
         * statement nunber...
         */
        sl=strdup("UL_");
        su=strdup("UU_");
        si=strdup("UU_");
    }
    else {
        /*  In order to get rid of at-sign, add 1 , LZ 010492 */
        asprintf(&sl,"UL_%s",entity_local_name(loop_label(loop_instr))+1);
        asprintf(&su,"UU_%s",entity_local_name(loop_label(loop_instr))+1);
        asprintf(&si,"UI_%s",entity_local_name(loop_label(loop_instr))+1);
    }
 
    /* tell callees that they mustn't try to evaluate the loop index */
 
    hash_put(hash_complexity_parameters, (char *)strdup(module_local_name(index)), 
             HASH_LOOP_INDEX);
 
    crange = range_to_complexity(rng, precond, effects_list);
    cbody = statement_to_complexity(s, precond, effects_list);
 
    cioh = make_constant_complexity((float)
                                    intrinsic_cost(LOOP_INIT_OVERHEAD, &ibioh));
    cboh = make_constant_complexity((float)
                                    intrinsic_cost(LOOP_BRANCH_OVERHEAD, &ibboh));
    /* cioh cboh are derived from overhead file "overhead" LZ, 280993 */
 
    complexity_polynome_add(&cbody, complexity_polynome(cboh));
 
    if ( execution_parallel_p(ex) ) {
        user_warning("loop_to_complexity", "DOALL not implemented yet\n");
    }
 
    clower = expression_to_complexity_polynome(range_lower(rng),
                                    precond, effects_list, 
                                    KEEP_SYMBOLS, MINIMUM_VALUE);
    if ( complexity_unknown_p(clower) ) {
        /*
           clower = make_single_var_complexity(1.0,
           (Variable)FindOrCreateEntity(mod_name, sl));
           */
        Variable var = (Variable)make_new_scalar_variable_with_prefix(sl, get_current_module_entity(),MakeBasic(is_basic_int));
        AddEntityToCurrentModule((entity)var);
        clower = make_single_var_complexity(1.0,var);
    }
 
    cupper = expression_to_complexity_polynome(range_upper(rng),
                                    precond, effects_list, 
                                    KEEP_SYMBOLS, MAXIMUM_VALUE);
    if ( complexity_unknown_p(cupper) ) {
        /*
           cupper = make_single_var_complexity(1.0,
           (Variable)FindOrCreateEntity(mod_name, su));
           */
        Variable var = (Variable)make_new_scalar_variable_with_prefix(su, get_current_module_entity(),MakeBasic(is_basic_int));
        AddEntityToCurrentModule((entity)var);
        cupper = make_single_var_complexity(1.0,var);
    }
 
    cincr  = expression_to_complexity_polynome(range_increment(rng),
                                    precond, effects_list, 
                                    KEEP_SYMBOLS, MINIMUM_VALUE);
 
    if ( complexity_constant_p(cincr) ) {
        int incr = complexity_TCST(cincr);
        if (incr == 0)
            user_error("loop_to_complexity", "null increment\n");
        else if ( incr < 0 ) {
            complexity cswap;
 
            complexity_scalar_mult(&cincr, -1.0);
            if ( incr != -1.0 ) {
                complexity_div(&clower, cincr);
                complexity_div(&cupper, cincr);
            }
            complexity_scalar_mult(&cincr, -1.0/incr);
            cswap = clower;
            clower = cupper;
            cupper = cswap;
        }
        else if ( incr != 1) {
            complexity_div(&clower, cincr);
            complexity_div(&cupper, cincr);
            complexity_scalar_mult(&cincr, 1.0/incr);
        }
        else if ( complexity_constant_p(clower) || complexity_constant_p(cupper) ) {
            ;
        }
    }
 
    if ( complexity_constant_p(clower) && complexity_constant_p(cupper)) {
        float lower = complexity_TCST(clower);
        float upper = complexity_TCST(cupper);
        if (lower>upper) {
            /* zero iteration for sure */
            comp = make_zero_complexity();
        }
        else {
            /* at least one iteration */
            comp = complexity_sigma(cbody, (Variable)index, clower, cupper);
        }
    }
    else {
        /* maybe some iteration */
        comp = complexity_sigma(cbody, (Variable)index, clower, cupper);
        /* an intermediate test based on preconditions would give better
           result with affine loop bounds */
    }
 
    /*
    if ( !complexity_constant_p(cincr) 
        || complexity_constant_p(clower) || complexity_constant_p(cupper) ) {
        complexity_div(&comp, cincr);
    }
    */
 
    if(!complexity_constant_p(cincr)) {
        if(complexity_is_monomial_p(cincr) && complexity_degree(cincr)==1) {
            complexity_div(&comp, cincr);
        }
        else {
            free_complexity(cincr);
            Variable var = (Variable)make_new_scalar_variable_with_prefix(si, get_current_module_entity(),MakeBasic(is_basic_int));
            AddEntityToCurrentModule((entity)var);
            cincr = make_single_var_complexity(1.0,var);
        }
    }
 
    if ( complexity_constant_p(comp) && complexity_TCST(comp) < 0 )
        comp = make_zero_complexity();
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "\n");
        fprintf(stderr, "@@@  body  complexity: ");
        complexity_fprint(stderr, cbody, false, true);
        fprintf(stderr, "@@@  range complexity: ");
        complexity_fprint(stderr, crange, false, true);
        fprintf(stderr, "@@@  lower     value : ");
        complexity_fprint(stderr, clower, false, true);
        fprintf(stderr, "@@@  upper     value : ");
        complexity_fprint(stderr, cupper, false, true);
        fprintf(stderr, "@@@  increment value : ");
        complexity_fprint(stderr, cincr, false, true);
        fprintf(stderr, "@@@  sigma complexity: ");
        complexity_fprint(stderr, comp, false, true);
    }
/*
    if ( !complexity_constant_p(cincr) ) {
        complexity_div(&comp, cincr);
    }
    else {
        float incr = complexity_TCST(cincr);
        if (incr == 0)
            user_error("loop_to_complexity", "null increment\n");
 
        if ( complexity_constant_p(clower) && complexity_constant_p(cupper) ) {
            float lower = complexity_TCST(clower);
            float upper = complexity_TCST(cupper);
            int times=0;
            float curf;
 
            for ( curf = lower; curf <= upper; curf += incr )
                times++;
 
            complexity_scalar_mult(&comp, 1./(float)times);
            if ( complexity_zero_p(comp) )
                comp = make_constant_complexity(1.0);
        }
        else {
            complexity_scalar_mult(&comp, 1.0/incr);
        }
    }
*/
    complexity_polynome_add(&comp, complexity_polynome(crange));
    complexity_polynome_add(&comp, complexity_polynome(cioh));
    complexity_stats_add(&comp, cincr);
    rangecount_guessed(complexity_rangecount(comp)) ++;
 
    complexity_rm(&crange);
    complexity_rm(&cioh);
    complexity_rm(&cboh);
    complexity_rm(&clower);
    complexity_rm(&cupper);
    complexity_rm(&cincr);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "@@@  loop total compl: ");
        complexity_fprint(stderr, comp, true, true);
        fprintf(stderr, "\n");
    }
 
    hash_del(hash_complexity_parameters, (char *)(module_local_name(index)));
    complexity_check_and_warn("loop_to_complexity", comp);    
 
    trace_off();
    free(sl);free(su);free(si);
    return(comp);
}

References AddEntityToCurrentModule(), asprintf, complexity_check_and_warn(), complexity_constant_p(), complexity_degree(), complexity_div(), complexity_fprint(), complexity_is_monomial_p(), complexity_polynome(), complexity_polynome_add(), complexity_rangecount, complexity_rm(), complexity_scalar_mult(), complexity_sigma(), complexity_stats_add(), complexity_TCST(), complexity_unknown_p(), empty_global_label_p(), entity_local_name(), entity_name, execution_parallel_p, expression_to_complexity_polynome(), fprintf(), free(), free_complexity(), get_bool_property(), get_current_module_entity(), hash_complexity_parameters, hash_del(), HASH_LOOP_INDEX, hash_put(), intrinsic_cost(), is_basic_int, KEEP_SYMBOLS, loop_body, LOOP_BRANCH_OVERHEAD, loop_execution, loop_index, LOOP_INIT_OVERHEAD, loop_label, loop_range, make_constant_complexity(), MAKE_INT_BASIC, make_new_scalar_variable_with_prefix(), make_single_var_complexity(), make_zero_complexity(), MakeBasic(), MAXIMUM_VALUE, MINIMUM_VALUE, module_local_name(), range_increment, range_lower, range_to_complexity(), range_upper, rangecount_guessed, statement_to_complexity(), strdup(), trace_off(), trace_on(), user_error, and user_warning.

Referenced by instruction_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

lu_back_substitution()

void lu_back_substitution	(	float *	a,
		int	n,
		int *	indx,
		float *	b
	)

back substitution

Parameters

indx

ndx

Definition at line 155 of file comp_matrice.c.

{
    int i,j;
    int ii = -1;
    float sum;
    int ll;
 
    for (i=0; i<n; i++ ) {
        ll = indx[i];
        sum = b[ll];
        b[ll] = b[i];
        if ( ii != -1 ) {
            for ( j=ii; j<=i-1; j++ ) {
                sum = sum -A(i,j)*b[j];
            }
        }
        else if ( sum != 0.0 ) {
            ii = i;
        }
        b[i] = sum;
    }
 
    /* back substitution */
    for ( i=n-1; i>=0; i-- ) {
        sum = b[i];
        if ( i < n ) {
            for ( j=i+1; j < n; j++ ) {
                sum = sum - A(i,j)*b[j];
            }
        }
        b[i] = sum/A(i,i);
    }
}

References A, and sum().

Referenced by float_matrice_inversion().

Here is the call graph for this function:

Here is the caller graph for this function:

lu_decomposition()

void lu_decomposition	(	float *	a,
		int	n,
		int *	indx,
		int *	pd
	)

comp_matrice.c

Added by AP, March 15th 93

If using gcc to compile, vv can be declared as vv[n] LZ 29/10/92 float vv[n];

loop over rows to get the implicit scaling information

loopover columns of Crout's method

Parameters

a	Modif by AP, March 15th 93 float a[n][n]; int indx[n];
indx	ndx
pd	d

Definition at line 65 of file comp_matrice.c.

{
    float aamax;
 
/* Added by AP, March 15th 93 */
    float vv[MAX_CONTROLS_IN_UNSTRUCTURED];
/* If using gcc to compile, vv can be declared as vv[n] LZ 29/10/92
    float vv[n];
*/
 
    int i,j,k;
    float sum,dum;
    int imax = 0;
    float tiny = 0.000001;
    
    *pd = 1;
 
    /* loop over rows to get the implicit scaling information */
    for (i=0; i<n; i++ ) {
        aamax = 0.0;
        for ( j=0; j<n; j++) {
            if ( fabs(A(i,j)) > aamax ) {
                aamax = fabs(A(i,j));
            }
        }
 
        if ( aamax == 0.0 ) {
            fprintf(stderr, "Singular matrix -- No non-zero element\n");
            user_error("lu_decomposition", "Module does not terminate\n");
        }
        vv[i] = 1./aamax;
    }
 
    /* loopover columns of Crout's method */
    for ( j=0; j<n; j++ ) {
        for ( i=0; i<=j-1; i++ ) {
            sum = A(i,j);
            for ( k=0; k<i; k++) {
                sum = sum - A(i,k)*A(k,j);
            }
            A(i,j) = sum;
        }
 
        aamax = 0.0;
 
        for ( i=j; (i<n) ; i++ ) {
            sum = A(i,j);
            for ( k=0; k<j; k++ ) {
                sum = sum - A(i,k)*A(k,j);
            }
            A(i,j) = sum;
            dum = vv[i]*fabs(sum);
            if ( dum >= aamax ) {
                imax = i;
                aamax = dum;
            }
        }
 
        if ( j != imax ) {
            for ( k=0; k<n; k++ ) {
                dum = A(imax,k);
                A(imax,k) = A(j,k);
                A(j,k) = dum;
            }
            *pd = - *pd;
            vv[imax] = vv[j];
        }
 
        indx[j] = imax;
        if ( A(j,j) == 0.0 )
            A(j,j) = tiny;
        if ( j != n-1 ) {
            dum = 1./A(j,j);
            for ( i=j+1; i<n; i++ ) {
                A(i,j) = A(i,j)*dum;
            }
        }
    }
}

References A, fprintf(), MAX_CONTROLS_IN_UNSTRUCTURED, sum(), and user_error.

Referenced by float_matrice_inversion().

Here is the call graph for this function:

Here is the caller graph for this function:

make_complexity_map()

void make_complexity_map

(

void

)

make_complexity_unknown()

complexity make_complexity_unknown

(

const char *

name

)

builds a new unknown complexity attached to a virtual package

Parameters

name

ame

Definition at line 81 of file comp_expr_to_pnome.c.

                                                      {
    entity package = FindEntity(TOP_LEVEL_MODULE_NAME,COMPLEXITY_PACKAGE_NAME);
    if(entity_undefined_p(package))
        package=make_empty_program(COMPLEXITY_PACKAGE_NAME,make_language_fortran());
    entity var = make_new_scalar_variable_with_prefix(name,package,make_basic_int(DEFAULT_INTEGER_TYPE_SIZE));
    return make_single_var_complexity(1.f,var);
}

References COMPLEXITY_PACKAGE_NAME, DEFAULT_INTEGER_TYPE_SIZE, entity_undefined_p, make_basic_int(), make_empty_program(), make_language_fortran(), make_new_scalar_variable_with_prefix(), make_single_var_complexity(), and package.

Referenced by simplify_sc_to_complexity(), and whileloop_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

make_constant_complexity()

complexity make_constant_complexity

(

double

)

make_single_var_complexity()

complexity make_single_var_complexity	(	double	,
		Variable
	)

make_zero_complexity()

complexity make_zero_complexity

(

void

)

make a zero complexity "0.0000 * TCST" with null statistics

Definition at line 238 of file comp_math.c.

{
    return make_constant_complexity(0.0000);
}

References make_constant_complexity().

Referenced by arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), complexity_dup(), complexity_mult(), complexity_rm(), complexity_scalar_mult(), complexity_sigma(), complexity_var_subst(), evaluate_var_to_complexity(), expression_to_complexity(), expression_to_complexity_polynome(), goto_to_complexity(), indices_to_complexity(), instruction_to_complexity(), loop_to_complexity(), new_block_to_complexity(), normalized_to_polynome(), power_op_handler(), pvecteur_to_polynome(), range_to_polynome(), reference_to_complexity(), reference_to_polynome(), simplify_sc_to_complexity(), statement_to_complexity(), summary_complexity(), syntax_to_complexity(), syntax_to_polynome(), translate_complexity_from_local_to_current_name(), unary_minus_op_handler(), and unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

minus_op_handler()

complexity minus_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 472 of file comp_expr_to_pnome.c.

{
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(CDR(args))),
                                           precond, effects_list, keep_symbols,
                                           -maximize);
 
    complexity_sub(&c1, c2);
    complexity_rm(&c2);
 
    return (c1);
}

References CAR, CDR, complexity_rm(), complexity_sub(), EXPRESSION, and expression_to_complexity_polynome().

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

multiply_op_handler()

complexity multiply_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 492 of file comp_expr_to_pnome.c.

{
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(CDR(args))),
                                           precond, effects_list, keep_symbols,
                                           maximize);
 
    complexity_mult(&c1, c2);
    complexity_rm(&c2);
 
    return (c1);
}

References CAR, CDR, complexity_mult(), complexity_rm(), EXPRESSION, and expression_to_complexity_polynome().

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

name_to_variable()

Variable name_to_variable

(

char *

name

)

Parameters

name

ame

Definition at line 172 of file polynome_ri.c.

{
    if (strcmp(name, TCST_NAME) == 0)
        return(TCST);
    /*
    else if (strcmp(name, UNKNOWN_VARIABLE_NAME) == 0) 
        return (UNKNOWN_VARIABLE);
    else if (strcmp(name, UNKNOWN_RANGE_NAME) == 0) 
        return (UNKNOWN_RANGE);
        */
    else {
        entity e = gen_find_tabulated(name, entity_domain);
        if (e != entity_undefined) 
            return ((Variable) e);
        else {
            user_warning("name_to_variable",
                         "entity '%s' not found:return chunk_undefined\n", name);
            return((Variable) chunk_undefined);
        }
    }
}

References chunk_undefined, entity_domain, entity_undefined, gen_find_tabulated(), TCST, TCST_NAME, and user_warning.

Referenced by polynome_sscanf(), and translate_complexity_from_local_to_current_name().

Here is the call graph for this function:

Here is the caller graph for this function:

node_successors_to_matrix()

void node_successors_to_matrix	(	control	,
		matrice	,
		int	,
		control	[],
		bool	[]
	)

noms_var()

char* noms_var

(

entity

e

)

comp_expr_to_pnome.c

Definition at line 60 of file comp_expr_to_pnome.c.

{
    bool entity_has_values_p();
    string external_value_name();
 
    if(e == (entity) TCST)
        return "";
    else
        return entity_has_values_p(e) ? (char *)module_local_name(e) :
            (char *)external_value_name(e);
}

References entity_has_values_p(), external_value_name(), module_local_name(), and TCST.

Referenced by evaluate_var_to_complexity(), plint(), plint_pas(), sc_resol_smith(), simplify_sc_to_complexity(), smith_int(), and sol_finale().

Here is the call graph for this function:

Here is the caller graph for this function:

normalized_to_polynome()

complexity normalized_to_polynome	(	normalized	no,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

2nd element of expression

Parameters

no	o
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 211 of file comp_expr_to_pnome.c.

{
    complexity comp = make_zero_complexity();
 
    trace_on("normalized -> pnome");
 
    if (normalized_linear_p(no) ) {
        Pvecteur pvect = (Pvecteur)normalized_linear(no);
        comp =  pvecteur_to_polynome(pvect, precond, effects_list, keep_symbols, maximize);
    }
    else
        pips_internal_error("vecteur undefined");
 
    trace_off();
    return(comp);
}

References make_zero_complexity(), normalized_linear, normalized_linear_p, pips_internal_error, pvecteur_to_polynome(), trace_off(), and trace_on().

Referenced by expression_to_complexity_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

plus_op_handler()

complexity plus_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 452 of file comp_expr_to_pnome.c.

{
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(CDR(args))),
                                           precond, effects_list, keep_symbols,
                                           maximize);
 
    complexity_add(&c1, c2);
    complexity_rm(&c2);
 
    return (c1);
}

References CAR, CDR, complexity_add(), complexity_rm(), EXPRESSION, and expression_to_complexity_polynome().

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_to_new_complexity()

complexity polynome_to_new_complexity

(

Ppolynome

pp

)

Create a complexity equal to Ppolynome pp with null statistics.

pp IS duplicated.

Parameters

pp

p

Definition at line 200 of file comp_math.c.

{
    varcount vc = make_varcount(0,0,0,0);
    rangecount rc = make_rangecount(0,0,0,0);
    ifcount ic = make_ifcount(0,0,0);
    Ppolynome ppdup;
    complexity comp;
 
    pips_assert("polynome_to_new_complexity", !POLYNOME_UNDEFINED_P(pp));
 
    ppdup = polynome_dup(pp);
    comp = make_complexity(ppdup, vc, rc, ic);
    ifdebug(1) {
        (void) complexity_consistent_p(comp);
    }
    return comp;
}

References complexity_consistent_p(), ifdebug, make_complexity(), make_ifcount(), make_rangecount(), make_varcount(), pips_assert, polynome_dup(), and POLYNOME_UNDEFINED_P.

Referenced by complexity_float_add(), complexity_sigma(), complexity_var_subst(), make_single_var_complexity(), pvecteur_to_polynome(), and reference_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

power_op_handler()

complexity power_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

polynome_rm(&(complexity_eval(c1)));

(Ppolynome) complexity_eval(c1) = pp;

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 589 of file comp_expr_to_pnome.c.

{
    float power;
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(CDR(args))),
                                           precond, effects_list, DONT_KEEP_SYMBOLS,
                                           maximize);
 
    if (complexity_constant_p(c2)) {
        power = complexity_TCST(c2);
        complexity_rm(&c2);
        if (power == (int) power) {
            Ppolynome pp = polynome_power_n(complexity_polynome(c1),
                                            (int) power);
            Ppolynome pt = complexity_eval(c1);
 
            /* polynome_rm(&(complexity_eval(c1))); */
            polynome_rm(&pt);
            /* (Ppolynome) complexity_eval(c1) = pp; */
            complexity_eval_(c1) = newgen_Ppolynome(pp);
            return (c1);
        }
    }
    else
        complexity_rm(&c2);
 
    complexity_rm(&c1);
    return (make_zero_complexity());
}

References CAR, CDR, complexity_constant_p(), complexity_eval, complexity_eval_, complexity_polynome(), complexity_rm(), complexity_TCST(), DONT_KEEP_SYMBOLS, EXPRESSION, expression_to_complexity_polynome(), make_zero_complexity(), newgen_Ppolynome, polynome_power_n(), and polynome_rm().

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

prc()

void prc

(

complexity

comp

)

Parameters

comp

omp

Definition at line 233 of file comp_util.c.

{
    complexity_fprint(stderr, comp, true, true);
}

References complexity_fprint().

Referenced by pvecteur_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

print_call_graph_with_complexities()

bool print_call_graph_with_complexities

(

const

string

)

Parameters

string

odule_name

Definition at line 254 of file comp_prettyprint.c.

{
  bool success = false;
  success = print_decorated_call_graph(module_name, get_text_complexities);
  return success;
}

References get_text_complexities(), module_name(), and print_decorated_call_graph().

Here is the call graph for this function:

print_code_as_a_graph_complexities()

bool print_code_as_a_graph_complexities

(

const

string

)

Parameters

string

od_name

Definition at line 234 of file comp_prettyprint.c.

{
    bool success;
 
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", true);
    success = print_code_complexities(mod_name);
    set_bool_property("PRETTYPRINT_UNSTRUCTURED_AS_A_GRAPH", false);
 
    return success;
}

References print_code_complexities(), and set_bool_property().

Here is the call graph for this function:

print_code_complexities()

bool print_code_complexities

(

const

string

)

comp_prettyprint.c

Parameters

string

odule_name

Definition at line 228 of file comp_prettyprint.c.

{
  is_user_view = false;
  return print_code_or_source_comp(module_name);
}

References is_user_view, module_name(), and print_code_or_source_comp().

Referenced by print_code_as_a_graph_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

print_icfg_with_complexities()

bool print_icfg_with_complexities

(

const

string

)

Parameters

string

odule_name

print_icfg_with_control_complexities()

bool print_icfg_with_control_complexities

(

const

string

)

Parameters

string

odule_name

print_icfg_with_loops_complexities()

bool print_icfg_with_loops_complexities

(

const

string

)

Parameters

string

odule_name

print_source_complexities()

bool print_source_complexities

(

const

string

)

Parameters

string

odule_name

Definition at line 245 of file comp_prettyprint.c.

{
  is_user_view = true;
  return print_code_or_source_comp(module_name);
}

References is_user_view, module_name(), and print_code_or_source_comp().

Here is the call graph for this function:

prp()

void prp

(

Ppolynome

pp

)

Parameters

pp

p

Definition at line 239 of file comp_util.c.

{
    polynome_fprint(stderr, pp, variable_name, is_inferior_pvarval);
    fprintf(stderr, "\n");
}

References fprintf(), is_inferior_pvarval(), polynome_fprint(), and variable_name().

Referenced by complexity_sigma().

Here is the call graph for this function:

Here is the caller graph for this function:

prv()

void prv

(

Pvecteur

pv

)

Parameters

pv

v

Definition at line 246 of file comp_util.c.

{
    vect_fprint_as_monome(stderr, pv, BASE_NULLE, variable_name, ".");
    fprintf(stderr, "\n");
}

References BASE_NULLE, fprintf(), variable_name(), and vect_fprint_as_monome().

Referenced by sc_projection_optim_along_vecteur_ofl().

Here is the call graph for this function:

Here is the caller graph for this function:

pvecteur_to_polynome()

complexity pvecteur_to_polynome	(	Pvecteur	pvect,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

The only element available of normalized.

bool must_be_written = false;

if (we_must_evaluate && must_be_written) {

should be multiplied by "val" here

We keep this symbol (including TCST) in the polynome

Parameters

pvect	vect
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 234 of file comp_expr_to_pnome.c.

{
    complexity comp = make_zero_complexity();
    Ppolynome ppvar;
    Pvecteur pv;
    Variable var;
    Value val;
    bool we_must_evaluate;
/*    bool must_be_written = false; */
 
    trace_on("pvecteur  -> pnome maximize is %d", maximize);
 
    if ( get_bool_property("COMPLEXITY_INTERMEDIATES") ) {
        fprintf(stderr, "expr->pnome: pvecteur = ");
        vect_fprint(stderr, pvect, variable_name);
    }
 
    for(pv=pvect; !VECTEUR_NUL_P(pv); pv = pv->succ) {
        var = vect_first_var(pv);
        val = vect_coeff(var, pv);
 
        we_must_evaluate =
            (var != TCST) &&
            (keep_symbols ? (!hash_contains_p(hash_complexity_parameters,
                                              (char *)module_local_name((entity)var)))
                          : true);
/*
        must_be_written = is_must_be_written_var(effects_list,
                                                 variable_local_name(var));
 
        if ( get_debug_level() >= 3 ) {
            fprintf(stderr, "Must be written var %s\n", variable_local_name(var) );
        }
*/
/*      
        if (we_must_evaluate && must_be_written) {
*/
        if (we_must_evaluate && get_bool_property("COMPLEXITY_EARLY_EVALUATION")) {
            complexity ctmp;
            ctmp = evaluate_var_to_complexity((entity)var, precond, effects_list, maximize);
            /* should be multiplied by "val" here */
            complexity_scalar_mult(&ctmp, VALUE_TO_FLOAT(val));
            complexity_add(&comp, ctmp);
        }
        else {
            /* We keep this symbol (including TCST) in the polynome */
            Value exp = VALUE_ONE;
            float coeff = VALUE_TO_FLOAT(val);
 
            ppvar = make_polynome(coeff, var, exp);
            if (complexity_zero_p(comp))
                comp = polynome_to_new_complexity(ppvar);
            else
                complexity_polynome_add(&comp, ppvar);
            varcount_symbolic(complexity_varcount(comp)) ++;
        }
    }
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "Pvecteur evaluation = ");
        prc(comp);
    }
 
    trace_off();
    return (comp);
}

References complexity_add(), complexity_polynome_add(), complexity_scalar_mult(), complexity_varcount, complexity_zero_p(), evaluate_var_to_complexity(), exp, fprintf(), get_bool_property(), hash_complexity_parameters, hash_contains_p, make_polynome(), make_zero_complexity(), module_local_name(), polynome_to_new_complexity(), prc(), Svecteur::succ, TCST, trace_off(), trace_on(), VALUE_ONE, VALUE_TO_FLOAT, varcount_symbolic, variable_name(), vect_coeff(), vect_first_var(), vect_fprint(), and VECTEUR_NUL_P.

Referenced by normalized_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

range_to_complexity()

complexity range_to_complexity	(	range	rng,
		transformer	precond,
		list	effects_list
	)

2nd element of syntax

Parameters

rng	ng
precond	recond
effects_list	ffects_list

Definition at line 1089 of file comp_scan.c.

{
    complexity compl = NULL, compu = NULL, compi = NULL;
    expression lower = range_lower(rng);
    expression upper = range_upper(rng);
    expression incr  = range_increment(rng);
    basic rngbasic;
 
    trace_on("range");
 
    if (!expression_undefined_p(lower))
        compl = expression_to_complexity(lower, &rngbasic, precond,
                                         effects_list);
    else 
        pips_internal_error("lower undefined");
 
    if (!expression_undefined_p(upper))
        compu = expression_to_complexity(upper, &rngbasic, precond,
                                         effects_list);
    else 
        pips_internal_error("upper undefined");
 
    if (!expression_undefined_p(incr))
        compi = expression_to_complexity(incr, &rngbasic, precond,
                                         effects_list);
    else 
        pips_internal_error("increment undefined");
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "\n");
        fprintf(stderr, "---  range lower complexity: ");
        complexity_fprint(stderr, compl, false, true);
        fprintf(stderr, "---  range upper complexity: ");
        complexity_fprint(stderr, compu, false, true);
        fprintf(stderr, "---  range incr  complexity: ");
        complexity_fprint(stderr, compi, false, true);
    }
 
    complexity_add(&compl, compu);
    complexity_add(&compl, compi);
    complexity_rm(&compu);
    complexity_rm(&compi);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "---  range total complexity: ");
        complexity_fprint(stderr, compl, true, true);
        fprintf(stderr, "\n");
    }
    complexity_check_and_warn("range_to_complexity", compl);
 
    trace_off();
    return(compl);
}

References complexity_add(), complexity_check_and_warn(), complexity_fprint(), complexity_rm(), expression_to_complexity(), expression_undefined_p, fprintf(), get_bool_property(), pips_internal_error, range_increment, range_lower, range_upper, trace_off(), and trace_on().

Referenced by loop_to_complexity(), and syntax_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

range_to_polynome()

complexity range_to_polynome	(	range	,
		transformer	,
		list	,
		bool	,
		int
	)

reference_to_complexity()

complexity reference_to_complexity	(	reference	ref,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

1st element of syntax

reference_to_complexity: return the complexity of the computing of the indices plus the complexity of one memory read Also return basic type of variable in *pbasic.

indices basic

ci=compindexation, ca=compaccess

ci=compindexation counts multi-dimension arrays indexation costs

Parameters

ref	ef
pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 952 of file comp_scan.c.

{
    entity var = reference_variable(ref);
    list ind = reference_indices(ref);
 
    const char* name = module_local_name(var);
    basic b = variable_basic(type_variable(entity_basic_concrete_type(var)));
    basic ib = MAKE_INT_BASIC;    /* indices basic */
    complexity comp, ci, ca;      /* ci=compindexation, ca=compaccess */
 
    trace_on("reference %s", entity_name(var));
 
    if ( basic_int_p(b)     || basic_float_p(b)   ||
         basic_complex_p(b) || basic_logical_p(b) )
        *pbasic = simple_basic_dup(b);
    else if (basic_string_p(b))
        *pbasic = MAKE_STRING_BASIC;
    else if (basic_derived_p(b) || basic_pointer_p(b)){
        *pbasic = MAKE_ADDRESS_BASIC;
    }
    else {
      user_warning("reference_to_complexity",
                     "basic_tag %d, not in 1->9\n", (int)basic_tag(b));
    }
 
    comp = indices_to_complexity(ind, &ib, precond, effects_list);
 
    /* ci=compindexation counts multi-dimension arrays indexation costs */
 
    switch ( gen_length(ind) ) {
    case 0:
        ci = make_zero_complexity();
        break;
    case 1:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(ONE_INDEX_NAME, &ib));
        break;
    case 2:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(TWO_INDEX_NAME, &ib));
        break;
    case 3:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(THREE_INDEX_NAME, &ib));
        break;
    case 4:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(FOUR_INDEX_NAME, &ib));
        break;
    case 5:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(FIVE_INDEX_NAME, &ib));
        break;
    case 6:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(SIX_INDEX_NAME, &ib));
        break;
    default:
        ci = make_constant_complexity((float)
                                      intrinsic_cost(SEVEN_INDEX_NAME, &ib));
    }
 
    if(entity_register_p(var))
      ca = make_zero_complexity();
    else
      ca = make_constant_complexity((float)
                                    intrinsic_cost(MEMORY_READ_NAME,
                                                   &ib));
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "\n");
        fprintf(stderr, ">>>  ref. %s argus   complexity: ", name);
        complexity_fprint(stderr, comp, false, true);
        fprintf(stderr, ">>>  ref. %s access  complexity: ", name);
        complexity_fprint(stderr, ca, false, true);
        fprintf(stderr, ">>>  ref. %s indices complexity: ", name);
        complexity_fprint(stderr, ci, false, true);
    }
 
    complexity_add(&comp, ca);
    complexity_add(&comp, ci);
    complexity_rm(&ca);
    complexity_rm(&ci);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, ">>>  ref. %s total   complexity: ", name);
        complexity_fprint(stderr, comp, true, true);
        fprintf(stderr,"\n");
    }
 
    complexity_check_and_warn("reference_to_complexity", comp);    
    
    trace_off();
    return(comp);
}

References basic_complex_p, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_pointer_p, basic_string_p, basic_tag, complexity_add(), complexity_check_and_warn(), complexity_fprint(), complexity_rm(), entity_basic_concrete_type(), entity_name, entity_register_p(), FIVE_INDEX_NAME, FOUR_INDEX_NAME, fprintf(), gen_length(), get_bool_property(), indices_to_complexity(), intrinsic_cost(), MAKE_ADDRESS_BASIC, make_constant_complexity(), MAKE_INT_BASIC, MAKE_STRING_BASIC, make_zero_complexity(), MEMORY_READ_NAME, module_local_name(), ONE_INDEX_NAME, ref, reference_indices, reference_variable, SEVEN_INDEX_NAME, simple_basic_dup(), SIX_INDEX_NAME, THREE_INDEX_NAME, trace_off(), trace_on(), TWO_INDEX_NAME, type_variable, user_warning, and variable_basic.

Referenced by syntax_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_to_polynome()

complexity reference_to_polynome	(	reference	ref,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

First element of the "syntax" domain.

bool must_be_written;

if it's an array: let us fail

We keep this symbol in the polynome

Parameters

ref	ef
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 307 of file comp_expr_to_pnome.c.

{
    complexity comp = make_zero_complexity();
    bool we_must_evaluate;
/*    bool must_be_written; */
    entity var = reference_variable(ref);
 
    trace_on("reference -> pnome");
 
    if ( reference_indices(ref) == NIL) {
        /* if it's an array: let us fail */
        we_must_evaluate = (keep_symbols ?
                            !hash_contains_p(hash_complexity_parameters,
                                             (char *)module_local_name((entity)var) ):
                            true);
/*
        must_be_written = is_must_be_written_var(effects_list, var);
 
        if ( get_debug_level() >= 3 ) {
            fprintf(stderr, "Must be written var %s\n", noms_var(var) );
        }
*/
/*
        if (we_must_evaluate && must_be_written) {
*/
        if (we_must_evaluate && get_bool_property("COMPLEXITY_EARLY_EVALUATION")) {
            comp = evaluate_var_to_complexity((entity)var, precond, effects_list, maximize);
        }
        else {         /* We keep this symbol in the polynome */
            Ppolynome pp = make_polynome((float) 1, (Variable) var, VALUE_ONE);
            comp = polynome_to_new_complexity(pp);
            varcount_symbolic(complexity_varcount(comp)) ++;
            polynome_rm(&pp);
        }
    }
 
    trace_off();
    return(comp);
}

References complexity_varcount, evaluate_var_to_complexity(), get_bool_property(), hash_complexity_parameters, hash_contains_p, make_polynome(), make_zero_complexity(), module_local_name(), NIL, polynome_rm(), polynome_to_new_complexity(), ref, reference_indices, reference_variable, trace_off(), trace_on(), VALUE_ONE, and varcount_symbolic.

Referenced by syntax_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_common_variables_from_hash_table()

void remove_common_variables_from_hash_table	(	entity	module,
		hash_table	hash_complexity_params
	)

Parameters

module	odule
hash_complexity_params	ash_complexity_params

Definition at line 985 of file comp_util.c.

{
    const char* module_name = module_local_name(module);
    list sefs_list;
 
    pips_assert("remove_common_variables_from_hash_table",
                entity_module_p(module));
 
    sefs_list = effects_to_list( (effects)
        db_get_memory_resource(DBR_SUMMARY_EFFECTS, module_name, true));
 
    MAPL(ce, { 
        effect obj = EFFECT(CAR(ce));
        reference r = effect_any_reference(obj);
        action ac = effect_action(obj);
        approximation ap = effect_approximation(obj);
        entity e = reference_variable(r);
 
        if ( action_read_p(ac) && approximation_exact_p(ap) ) {
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr, "%s deleted\n", module_local_name(e));
            }
            hash_del(hash_complexity_params, (char *) module_local_name(e));
        }
    }, sefs_list);
}

References action_read_p, approximation_exact_p, CAR, db_get_memory_resource(), EFFECT, effect_action, effect_any_reference, effect_approximation, effects_to_list(), entity_module_p(), fprintf(), get_bool_property(), hash_del(), MAPL, module, module_local_name(), module_name(), pips_assert, and reference_variable.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_formal_parameters_from_hash_table()

void remove_formal_parameters_from_hash_table	(	entity	mod,
		hash_table	hash_complexity_params
	)

Parameters

mod	od
hash_complexity_params	ash_complexity_params

Definition at line 791 of file comp_util.c.

{
    list decl;
 
    pips_assert("remove_formal_parameters_from_hash_table",
                entity_module_p(mod));
    decl = code_declarations(value_code(entity_initial(mod)));
 
    MAPL(pe, {
        entity param = ENTITY(CAR(pe));
        if (storage_formal_p(entity_storage(param)))
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr,"storage_formal %s to be deleted\n",
                        entity_name(param));
            }
            hash_del(hash_complexity_params, (char *) module_local_name(param));
    }, decl);
}

References CAR, code_declarations, ENTITY, entity_initial, entity_module_p(), entity_name, entity_storage, fprintf(), get_bool_property(), hash_del(), MAPL, module_local_name(), pips_assert, storage_formal_p, and value_code.

Referenced by any_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_formal_parameters_by_real_ones()

complexity replace_formal_parameters_by_real_ones	(	complexity	comp,
		entity	mod,
		list	args,
		transformer	precond,
		list	effects_list
	)

transform formal params into real ones (args) in complexity comp

print out the entity name for debugging purpose

if formal parameter...

minus one because offsets start at 1 not 0

Parameters

comp	omp
mod	od
args	rgs
precond	recond
effects_list	ffects_list

Definition at line 519 of file comp_math.c.

{
    complexity cresult = complexity_dup(comp);
    complexity carg, ctemp;
    list decl = code_declarations(value_code(entity_initial(mod)));
    char *param_name;
    int param_rank;
    list argument;
 
    pips_assert("replace_formal_parameters_by_real_ones", entity_module_p(mod));
 
    FOREACH (ENTITY, param,decl) {
        storage st = entity_storage(param);
 
        /* print out the entity name for debugging purpose */
        if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
            fprintf(stderr,"in REPLACE, entity name is %s\n",
                    entity_name(param));
        }
 
        if (storage_formal_p(st)) {     
            /* if formal parameter... */
            param_name = entity_name(param);
            param_rank = formal_offset(storage_formal(st));
 
            argument = gen_nthcdr(param_rank-1,args);/* minus one because offsets start at 1 not 0 */
 
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr,"formal offset=%d, formal name=%s\n",
                        param_rank, param_name);
            }
 
            carg = expression_to_complexity_polynome(EXPRESSION(CAR(argument)),
                    precond,
                    effects_list,
                    KEEP_SYMBOLS,
                    EXACT_VALUE);
 
            if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
                fprintf(stderr,"variable name is %s\n", variable_name((Variable)param) );
            }
 
            ctemp = complexity_var_subst(cresult, (Variable)param, carg);
            complexity_rm(&cresult); 
            cresult = complexity_dup(ctemp);
            complexity_rm(&carg);
        }
    }
   
    return (cresult);
}

References CAR, code_declarations, complexity_dup(), complexity_rm(), complexity_var_subst(), ENTITY, entity_initial, entity_module_p(), entity_name, entity_storage, EXACT_VALUE, EXPRESSION, expression_to_complexity_polynome(), FOREACH, formal_offset, fprintf(), gen_nthcdr(), get_bool_property(), KEEP_SYMBOLS, pips_assert, storage_formal, storage_formal_p, value_code, and variable_name().

Referenced by call_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_complexity_map()

void reset_complexity_map

(

void

)

Referenced by any_complexities(), bdsc_code_instrumentation(), computation_intensity(), dsc_code_parallelization(), generic_print_xml_application(), hbdsc_parallelization(), if_conversion_init(), print_code_or_source_comp(), print_xml_code(), and summary_complexity().

Here is the caller graph for this function:

set_complexity_map()

void set_complexity_map

(

statement_mapping

)

Referenced by any_complexities(), bdsc_code_instrumentation(), computation_intensity(), dsc_code_parallelization(), hbdsc_parallelization(), if_conversion_init(), print_code_or_source_comp(), print_xml_code(), and summary_complexity().

Here is the caller graph for this function:

simplify_sc_to_complexity()

complexity simplify_sc_to_complexity	(	Psysteme	ps,
		Variable	var
	)

This function is recently added by L.Zhou June 5, 91 simplify_sc_to_complexity(Psysteme ps, Variable var) It looks for the egality formula containing (Variable)var in the system (Psysteme)ps.

If ps->egalites is NULL, zero complexity is returned. The rest of the variable in that formula should be the known variable for example: formal parameter(s), inductible variable, etc. EX: M1 - M2 = 1 where M1 is formal parameter where M2 is an inductible variable This function returns M2 = M1 - 1 packed in the polynomial of the complexity the statistics of this complexity should be all zero.

Parameters

ps	s
var	ar

Definition at line 798 of file comp_expr_to_pnome.c.

{
    complexity comp = make_zero_complexity();
    Value var_coeff=VALUE_ONE;
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        sc_fprint(stderr, ps, (get_variable_name_t) noms_var);
    }
 
    if ( !SC_UNDEFINED_P(ps) && !CONTRAINTE_UNDEFINED_P(ps->egalites) ) {
        Pvecteur v = (ps->egalites)->vecteur;
 
        for  ( ; !VECTEUR_NUL_P(v); v=v->succ ) {
            if ( v->var != TCST ) {
                if ( v->var != (Variable)var ) {
                    complexity c = make_single_var_complexity
                        (VALUE_TO_FLOAT(v->val),v->var);
                    complexity_add(&comp, c);
                    complexity_rm(&c);
                }
                else {
                    var_coeff = value_uminus(v->val);
                }
            }
            else {
                complexity c = make_constant_complexity
                    (VALUE_TO_FLOAT(v->val));
                complexity_add(&comp, c);
                complexity_rm(&c);
            }
        }
    }
    else {
        bool b = hash_contains_p(hash_complexity_parameters,
                           (char *)module_local_name((entity)var));
 
        if ( b )
            comp = make_single_var_complexity(1.0, (Variable)var);
        else
            comp = make_complexity_unknown(UNKNOWN_VARIABLE_NAME);
    }
 
    complexity_scalar_mult(&comp,1.0/VALUE_TO_FLOAT(var_coeff));
    varcount_unknown(complexity_varcount(comp)) ++;
 
    return (comp);
}

References complexity_add(), complexity_rm(), complexity_scalar_mult(), complexity_varcount, CONTRAINTE_UNDEFINED_P, get_bool_property(), hash_complexity_parameters, hash_contains_p, make_complexity_unknown(), make_constant_complexity(), make_single_var_complexity(), make_zero_complexity(), module_local_name(), noms_var(), sc_fprint(), Svecteur::succ, TCST, UNKNOWN_VARIABLE_NAME, Svecteur::val, VALUE_ONE, VALUE_TO_FLOAT, value_uminus, Svecteur::var, varcount_unknown, and VECTEUR_NUL_P.

Referenced by evaluate_var_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_complexity_undefined_p()

bool statement_complexity_undefined_p

(

statement

)

statement_to_complexity()

complexity statement_to_complexity	(	statement	,
		transformer	,
		list
	)

store_statement_complexity()

void store_statement_complexity	(	statement	,
		complexity
	)

Referenced by statement_to_complexity().

Here is the caller graph for this function:

subscript_to_complexity()

complexity subscript_to_complexity	(	subscript	sub,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

G:let us assume . cost 1

Parameters

sub	ub
pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 860 of file comp_scan.c.

                                                                {
 
    complexity cl = expression_to_complexity(
            subscript_array(sub),
            pbasic,
            precond,
            effects_list);
    complexity cr = indices_to_complexity(
            subscript_indices(sub),
            pbasic,
            precond,
            effects_list);
    complexity_add(&cl,cr);
    complexity_rm(&cr);
    complexity_float_add(&cl,1.f);/*SG:let us assume . cost 1 */
    return cl;
 
}

References complexity_add(), complexity_float_add(), complexity_rm(), expression_to_complexity(), indices_to_complexity(), subscript_array, and subscript_indices.

Referenced by syntax_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

summary_complexity()

bool summary_complexity

(

const

string

)

summary_comp_dup = complexity_dup(summary_comp);

Parameters

string

odule_name

Definition at line 179 of file comp_scan.c.

{
  complexity summary_comp = make_zero_complexity();// complexity_undefined;
  complexity summary_comp_dup = make_zero_complexity();// complexity_undefined;
 
    set_current_module_statement( (statement)
        db_get_memory_resource(DBR_CODE, module_name, true ) );
 
    set_complexity_map( (statement_mapping)
                       db_get_memory_resource(DBR_COMPLEXITIES, module_name, true));
    summary_comp = load_statement_complexity( get_current_module_statement() );
 
    trace_on("summary complexity %s", module_name);
    debug_on("COMPLEXITY_DEBUG_LEVEL");
 
    if ( summary_comp == COMPLEXITY_NOT_FOUND )
        pips_internal_error("No summary complexity!");
    else {
        /* summary_comp_dup = complexity_dup(summary_comp); */
        summary_comp_dup = copy_complexity(summary_comp);
    }
 
    pips_assert("summary_comp is conssten",
                complexity_consistent_p(summary_comp));
    pips_assert("summary_comp_dup is consistent",
                complexity_consistent_p(summary_comp_dup));
 
    trace_off();
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr,"\n");
        fprintf(stderr,"Before ======== SUMMARY ; module %s\n",module_name);
    }
 
    debug_off();
 
    DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_COMPLEXITY,
                           strdup(module_name),
                           (char *) summary_comp_dup);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr,"After  ======== SUMMARY ; module %s\n",module_name);
    }
 
    reset_complexity_map();
    reset_current_module_statement();
 
    return true;
}

References complexity_consistent_p(), COMPLEXITY_NOT_FOUND, copy_complexity(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, fprintf(), get_bool_property(), get_current_module_statement(), load_statement_complexity(), make_zero_complexity(), module_name(), pips_assert, pips_internal_error, reset_complexity_map(), reset_current_module_statement(), set_complexity_map(), set_current_module_statement(), strdup(), trace_off(), and trace_on().

Here is the call graph for this function:

syntax_to_complexity()

complexity syntax_to_complexity	(	syntax	s,
		basic *	pbasic,
		transformer	precond,
		list	effects_list
	)

the only available element of expression

A cost for casting could be added, although casting is mostly used for typing issue. However, (float) 2 has a cost.

TypeCast operation added by Molka Becher to complexity_cost_tables for handling the cost of cast when it is necessary, 24 March 2011

Compiler generated constant: equivalent to a constant load --> 0

Parameters

pbasic	basic
precond	recond
effects_list	ffects_list

Definition at line 881 of file comp_scan.c.

{
  complexity comp = make_zero_complexity();// complexity_undefined;
 
  trace_on("syntax");
 
  switch (syntax_tag(s)) {
  case is_syntax_reference:
    comp = reference_to_complexity(syntax_reference(s), pbasic,
                                   precond, effects_list);
    break;
  case is_syntax_range:
    comp = range_to_complexity(syntax_range(s), precond, effects_list);
    break;
  case is_syntax_call:
    comp = call_to_complexity(syntax_call(s), pbasic, precond, effects_list);
    break;
  case is_syntax_cast: {
    cast c = syntax_cast(s);
    /* A cost for casting could be added, although casting is mostly
       used for typing issue. However, (float) 2 has a cost.  */
        /* TypeCast operation added by Molka Becher to complexity_cost_tables 
           for handling the cost of cast when it is necessary, 24 March 2011 */
    basic ib = MAKE_INT_BASIC;
    comp = expression_to_complexity(cast_expression(c), pbasic, precond, effects_list);
    complexity c1 = make_constant_complexity((float)intrinsic_cost(TYPE_CAST_COST, &ib));
    complexity_add(&comp, c1);
    complexity_rm(&c1);
    break;
  }
  case is_syntax_sizeofexpression: {
    sizeofexpression se = syntax_sizeofexpression(s);
    if(sizeofexpression_expression_p(se))
      comp = expression_to_complexity(sizeofexpression_expression(se),
                                      pbasic, precond, effects_list);
    else {
      /* Compiler generated constant: equivalent to a constant load --> 0*/
      comp = make_zero_complexity();
    }
    break;
  }
  case is_syntax_subscript:
    comp=subscript_to_complexity(syntax_subscript(s),pbasic,precond,effects_list);
    break;
  case is_syntax_application:
    pips_internal_error("Not implemented yet");
    break;
  case is_syntax_va_arg:
    pips_internal_error("Not implemented yet");
    break;
  default:
    pips_internal_error("syntax_tag %d, not in %d->%d", (int)syntax_tag(s),
               is_syntax_reference, is_syntax_va_arg);
  }
 
  complexity_check_and_warn("syntax_to_complexity", comp);
 
  trace_off();
  return(comp);
}

References call_to_complexity(), cast_expression, complexity_add(), complexity_check_and_warn(), complexity_rm(), expression_to_complexity(), intrinsic_cost(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_constant_complexity(), MAKE_INT_BASIC, make_zero_complexity(), pips_internal_error, range_to_complexity(), reference_to_complexity(), sizeofexpression_expression, sizeofexpression_expression_p, subscript_to_complexity(), syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, syntax_tag, trace_off(), trace_on(), and TYPE_CAST_COST.

Referenced by expression_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

syntax_to_polynome()

complexity syntax_to_polynome	(	syntax	synt,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

1st element of expression

This expression cannot be used within a polynomial, just like an array reference

Parameters

synt	ynt
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 166 of file comp_expr_to_pnome.c.

{
  complexity comp = make_zero_complexity();// complexity_undefined;
 
  trace_on("syntax -> pnome");
 
  switch (syntax_tag(synt)) {
  case is_syntax_reference:
    comp = reference_to_polynome(syntax_reference(synt),
                                 precond, effects_list, keep_symbols, maximize);
    break;
  case is_syntax_range:
    comp = range_to_polynome(syntax_range(synt),
                             precond, effects_list, keep_symbols, maximize);
    break;
  case is_syntax_call:
    comp = call_to_polynome(syntax_call(synt),
                            precond, effects_list, keep_symbols, maximize);
    break;
  case is_syntax_cast:
    comp = cast_to_polynome(syntax_cast(synt),
                            precond, effects_list, keep_symbols, maximize);
    break;
  case is_syntax_sizeofexpression:
  case is_syntax_subscript:
  case is_syntax_application:
  case is_syntax_va_arg:
    /* This expression cannot be used within a polynomial, just like
       an array reference */
    comp = make_zero_complexity();
    break;
  default:
    pips_internal_error("Unexpected tag:%d\n", syntax_tag(synt));
  }
 
  trace_off();
  return (comp);
}

References call_to_polynome(), cast_to_polynome(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_zero_complexity(), pips_internal_error, range_to_polynome(), reference_to_polynome(), syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_tag, trace_off(), and trace_on().

Referenced by expression_to_complexity_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

test_to_complexity()

complexity test_to_complexity	(	test	test_instr,
		transformer	precond,
		list	effects_list
	)

2nd element of instruction

Parameters

test_instr	est_instr
precond	recond
effects_list	ffects_list

Definition at line 414 of file comp_scan.c.

{
    complexity comp, ctrue, cfalse, ctemp;
    basic testbasic;
 
    trace_on("test");
 
    ctrue = statement_to_complexity(test_true(test_instr), precond, effects_list);
    cfalse = statement_to_complexity(test_false(test_instr), precond, effects_list);
    comp = expression_to_complexity(test_condition(test_instr),
                                    &testbasic, precond, effects_list);
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "\n");
        fprintf(stderr, "YYY  test true  complexity: ");
        complexity_fprint(stderr, ctrue, false, true);
        fprintf(stderr, "YYY  test false complexity: ");
        complexity_fprint(stderr, cfalse, false, true);
        fprintf(stderr, "YYY  test cond. complexity: ");
        complexity_fprint(stderr, comp, false, true);
    }
 
    ctemp = complexity_dup(ctrue);
    complexity_add(&ctemp, cfalse);
    complexity_scalar_mult(&ctemp, 0.5);
    complexity_add(&comp, ctemp);
    complexity_rm(&ctemp);
 
    if ( !complexity_zero_p(comp) )
        ifcount_halfhalf(complexity_ifcount(comp)) ++;
 
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "YYY  test total complexity: ");
        complexity_fprint(stderr, comp, true, true);
        fprintf(stderr, "\n");
    }
    complexity_check_and_warn("test_to_complexity", comp);    
 
    trace_off();
    return(comp);
}

References complexity_add(), complexity_check_and_warn(), complexity_dup(), complexity_fprint(), complexity_ifcount, complexity_rm(), complexity_scalar_mult(), complexity_zero_p(), expression_to_complexity(), fprintf(), get_bool_property(), ifcount_halfhalf, statement_to_complexity(), test_condition, test_false, test_true, trace_off(), and trace_on().

Referenced by instruction_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

trace_off()

void trace_off

(

void

)

"trace off"

Definition at line 714 of file comp_util.c.

{
    if (get_bool_property("COMPLEXITY_TRACE_CALLS")) {
        char *indentstring = (char*) malloc(99);
        bool b = (call_level >= 0);
        int i,k=1;
 
        indentstring[0] = '\0';
        call_level--;
        for (i=0; i< (b ? call_level : - call_level); i++) {
            indentstring = strcat(indentstring,
                                  strdup(b ? ( (k>0) ? INDENT_BLANKS
                                                     : INDENT_VLINE )
                                           : INDENT_BACK));
            k = ( k<INDENT_INTERVAL ? k+1 : 0 );
        }
        fprintf(stderr, "%s<\n", indentstring);
        free(indentstring);
    }
}

References call_level, fprintf(), free(), get_bool_property(), INDENT_BACK, INDENT_BLANKS, INDENT_INTERVAL, INDENT_VLINE, malloc(), and strdup().

Referenced by any_complexities(), arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), cast_to_polynome(), evaluate_var_to_complexity(), expression_to_complexity(), expression_to_complexity_polynome(), indices_to_complexity(), instruction_to_complexity(), loop_to_complexity(), new_block_to_complexity(), normalized_to_polynome(), pvecteur_to_polynome(), range_to_complexity(), range_to_polynome(), reference_to_complexity(), reference_to_polynome(), statement_to_complexity(), summary_complexity(), syntax_to_complexity(), syntax_to_polynome(), test_to_complexity(), and unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

trace_on()

void trace_on	(	char *	fmt,
			...
	)

Parameters

fmt

mt

Definition at line 684 of file comp_util.c.

{
    if (get_bool_property("COMPLEXITY_TRACE_CALLS")) {
        va_list args;
        char *indentstring = (char*) malloc(99);
        bool b = (call_level >= 0);
        int i,k=1;
 
        indentstring[0] = '\0';
 
        for (i=0; i< (b ? call_level : - call_level); i++) {
            indentstring = strcat(indentstring,
                                  strdup(b ? ( (k>0) ? INDENT_BLANKS
                                                     : INDENT_VLINE )
                                           : INDENT_BACK));
            k = ( k<INDENT_INTERVAL ? k+1 : 0 );
        }
 
        fprintf(stderr, "%s>", indentstring);
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        fprintf(stderr, "\n");
        va_end(args);
 
        free(indentstring);
        call_level++;
    }
}

References call_level, fprintf(), free(), get_bool_property(), INDENT_BACK, INDENT_BLANKS, INDENT_INTERVAL, INDENT_VLINE, malloc(), and strdup().

Referenced by any_complexities(), arguments_to_complexity(), block_to_complexity(), call_to_complexity(), call_to_polynome(), cast_to_polynome(), evaluate_var_to_complexity(), expression_to_complexity(), expression_to_complexity_polynome(), indices_to_complexity(), instruction_to_complexity(), loop_to_complexity(), new_block_to_complexity(), normalized_to_polynome(), pvecteur_to_polynome(), range_to_complexity(), range_to_polynome(), reference_to_complexity(), reference_to_polynome(), statement_to_complexity(), summary_complexity(), syntax_to_complexity(), syntax_to_polynome(), test_to_complexity(), and unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_complexity_from_local_to_current_name()

complexity translate_complexity_from_local_to_current_name	(	complexity	callee_comp,
		string	oldname,
		string	newname
	)

translate_complexity_from_local_to_current_name(callee_comp,oldname,newname) B:M -> A:M if A calls B 5 Feb.

93 LZ

This is not general enough to handle: B:M -> A:N or B:M to A:N+1 FI, 3 March 1994

constant complexity

The basis associated to a polynomial includes the constant term!

constant complexity

Parameters

callee_comp	allee_comp
oldname	ldname
newname	ewname

Definition at line 1100 of file comp_util.c.

{
    Ppolynome pp = complexity_polynome(callee_comp);
    Pbase pb = polynome_used_var(pp, is_inferior_pvarval);
    Pbase pbcur = BASE_UNDEFINED;
    complexity comp = make_zero_complexity();
    complexity old_comp = complexity_dup(callee_comp);
 
    if(BASE_NULLE_P(pb)) {
        /* constant complexity */
        comp = complexity_dup(callee_comp);
        return comp;
    }
 
    /* The basis associated to a polynomial includes the constant term! */
    if(base_dimension(pb)==1 && term_cst(pb)) {
        /* constant complexity */
        comp = complexity_dup(callee_comp);
        return comp;
    }
 
    for (pbcur=pb; pbcur != VECTEUR_NUL ; pbcur = pbcur->succ ) {
        Variable var = pbcur->var;
        char * stmp = strdup(variable_name(var));
 
        char *s = stmp;
        char *t = strchr(stmp,':');
 
        if ( t != NULL ) {
            int length = (int)(t - s);
            char *cur_name = (char *)malloc(100);
 
            (void) strncpy(cur_name,stmp,length);
            * (cur_name+length) = '\0';
 
            if ( 1 || strncmp(cur_name, oldname, length) == 0 ) {
                Variable newvar = name_to_variable(concatenate(strdup(newname),
                                                               ":",strdup(t+1),NULL));
                if ( newvar != (Variable) chunk_undefined ) {
                    complexity compsubst = make_single_var_complexity(1.0, newvar);
 
/*
                    polynome_chg_var(&pp, var, newvar);
*/
                    comp = complexity_var_subst(old_comp, var, compsubst);
                    old_comp = complexity_dup(comp);
                }
                else {
                    comp = complexity_dup(old_comp);
                    old_comp = complexity_dup(comp);
                }                   
            }
        }
    }
    return (comp);
}

References base_dimension, BASE_NULLE_P, BASE_UNDEFINED, chunk_undefined, complexity_dup(), complexity_polynome(), complexity_var_subst(), concatenate(), int, is_inferior_pvarval(), make_single_var_complexity(), make_zero_complexity(), malloc(), name_to_variable(), polynome_used_var(), strdup(), Svecteur::succ, term_cst, Svecteur::var, variable_name(), and VECTEUR_NUL.

Referenced by fetch_callees_complexities().

Here is the call graph for this function:

Here is the caller graph for this function:

unary_minus_op_handler()

complexity unary_minus_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 527 of file comp_expr_to_pnome.c.

{
    complexity c2 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           -maximize);
    complexity c1 = make_zero_complexity();
 
    complexity_sub(&c1, c2);
    complexity_rm(&c2);
 
    return (c1);
}

References CAR, complexity_rm(), complexity_sub(), EXPRESSION, expression_to_complexity_polynome(), and make_zero_complexity().

Referenced by call_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

unary_plus_op_handler()

complexity unary_plus_op_handler	(	list	args,
		transformer	precond,
		list	effects_list,
		bool	keep_symbols,
		int	maximize
	)

Parameters

args	rgs
precond	recond
effects_list	ffects_list
keep_symbols	eep_symbols
maximize	aximize

Definition at line 545 of file comp_expr_to_pnome.c.

{
    complexity c1 = expression_to_complexity_polynome(EXPRESSION(CAR(args)),
                                           precond, effects_list, keep_symbols,
                                           maximize);
 
    return (c1);
}

References CAR, EXPRESSION, and expression_to_complexity_polynome().

Here is the call graph for this function:

uniform_complexities()

bool uniform_complexities

(

const string

module_name

)

declares the static variable complexity_map and defines its access functions

bool complexities(module_name) Entry point called by the pips makefile

"hash_callee_to_complexity" contains a list of summary_complexity of callees, Non-recursive: callees complexities are supposed to be computed when arriving here.

"hash_complexity_parameters" contains the list of variables that we don't want to evaluate; so they will appear in the polynomial. All other variables (except for the loop indices) are evaluated as the scan proceeds, thanks to semantic analysis. Those which can't be evaluated are replaced by the pseudo-variable UNKNOWN_VARIABLE, which will be given an arbitrary value at the end of the evaluation.

Parameters

module_name

odule_name

Definition at line 79 of file comp_scan.c.

{
    bool success = true;
 
    //set_string_property("COMPLEXITY_COST_TABLE", "all_1");
    success = any_complexities(module_name);
 
    return success;
}

References any_complexities(), and module_name().

Here is the call graph for this function:

unstructured_to_complexity()

complexity unstructured_to_complexity	(	unstructured	unstr,
		transformer	precond,
		list	effects_list
	)

comp_unstr.c

comp_unstr.c

complexity unstructured_to_complexity(unstructured unstr; transformer precond; list effects_list;

Return the complexity of the unstructured graph unstr whose nodes are controls.

First runs through the graph to compute nodes' complexities, the total number of nodes, and give a number to each node. This is done in "controls_to_hash_table()".

Then runs again through it to fill the probability matrix [Pij] ( Pij = probability to go to node j when you're in node i) This is done in "build_probability_matrix()"

Then computes A = I-P, then inv_A = 1/A with the matrix package.

MAX_CONTROLS_IN_UNSTRUCTURED = 100

A is identity matrix I

B = A - P = I - P

matrice_general_inversion(B, A, n_controls);

A = 1/(B)

This region will call C routines. LZ 20/10/92

the "global" complexity is: comp = a11 * C1 + a12 * C2 + ... + a1n * Cn where Ci = complexity of control #i

Modif by AP, March 15th 93: old version had non constant int in dim decl float fa[n_controls][n_controls]; int indx[n_controls]; int d;

Parameters

unstr	nstr
precond	recond
effects_list	ffects_list

Definition at line 75 of file comp_unstr.c.

{
    complexity comp = make_zero_complexity(); 
    hash_table hash_control_to_complexity = hash_table_make(hash_pointer, 
                                            MAX_CONTROLS_IN_UNSTRUCTURED);
    int i, j, n_controls = 0;
    control control_array[MAX_CONTROLS_IN_UNSTRUCTURED];
    matrice P, A, B;
 
    trace_on("unstructured");
 
    controls_to_hash_table(unstructured_control(unstr),
                           &n_controls,
                           control_array,
                           hash_control_to_complexity,
                           precond,
                           effects_list);
    
     
    P = average_probability_matrix(unstr, n_controls, control_array);
    A = matrice_new(n_controls, n_controls);
    B = matrice_new(n_controls, n_controls);
 
    /* A is identity matrix I */
    matrice_identite(A, n_controls, 0);   
    /* B = A - P =  I - P */
    matrice_substract(B, A, P, n_controls, n_controls);  
 
    if (get_debug_level() >= 5) {
        fprintf(stderr, "I - P =");
        matrice_fprint(stderr, B, n_controls, n_controls);
    }
 
    /* matrice_general_inversion(B, A, n_controls);  */    
    /* A = 1/(B) */
    /* This region will call C routines. LZ 20/10/92  */
 
    /* 
       the "global" complexity is:
       comp = a11 * C1 + a12 * C2 + ... + a1n * Cn
       where Ci = complexity of control #i
     */
 
    if ( n_controls < MAX_CONTROLS_IN_UNSTRUCTURED ) {
 
        /* Modif by AP, March 15th 93: old version had non constant int in dim decl
        float fa[n_controls][n_controls];
        int indx[n_controls];
        int d;
        */
        float *fa = (float *) malloc(n_controls*n_controls*sizeof(float));
        int *indx = (int *) malloc(sizeof(int) * n_controls);
        int d;
 
        for (i=1; i<=n_controls; i++) {
            for (j=1; j<=n_controls; j++ ) {
                Value n = ACCESS(B, n_controls, i, j),
                      de = DENOMINATOR(B);
                float f1 = VALUE_TO_FLOAT(n),
                      f2 = VALUE_TO_FLOAT(de);
                FA(i-1,j-1) = f1/f2;
            }
        }
 
        if ( get_debug_level() >= 5 ) {
            fprintf(stderr, "Before float matrice inversion\n\n");
        }
 
        if ( get_debug_level() >= 9 ) {
            fprintf(stderr, "(I - P) =\n");
            for (i=0;i<n_controls;i++) {
                for (j=0;j<n_controls;j++)
                   fprintf(stderr, "%4.2f ",FA(i,j) );
                fprintf(stderr, "\n");
            }
        }
 
        float_matrice_inversion(fa, n_controls, indx, &d);
 
        if ( get_debug_level() >= 5 ) {
            fprintf(stderr, "After  float matrice inversion\n\n");
        }
 
        if ( get_debug_level() >= 9 ) {
            fprintf(stderr, "(I - P)^(-1) =\n");
            for (i=0;i<n_controls;i++) {
                for (j=0;j<n_controls;j++)
                   fprintf(stderr, "%4.2f ",FA(i,j) );
                fprintf(stderr, "\n");
            }
        }
 
        for (i=1; i<=n_controls; i++) {
            control conti = control_array[i];
            complexity compi = (complexity) 
                hash_get(hash_control_to_complexity, (char *) conti);
            float f = FA(0,i-1);
 
            if ( get_debug_level() >= 5 ) {
                fprintf(stderr, "control $%p:f=%f, compl.=", conti, f);
                complexity_fprint(stderr, compi, true, false);
            }
 
            complexity_scalar_mult(&compi, f);
            complexity_add(&comp, compi);
        }
    }
    else
        pips_internal_error("Too large to compute");
 
    if (get_debug_level() >= 5) {
        fprintf(stderr, "cumulated complexity=");
        complexity_fprint(stderr, comp, true, false);
    }
 
    matrice_free(B);
    matrice_free(A);
    matrice_free(P);
 
    hash_table_free(hash_control_to_complexity);
 
    complexity_check_and_warn("unstructured_to_complexity", comp);    
 
    trace_off();
    return(comp);
}

References A, ACCESS, average_probability_matrix(), B, complexity_add(), complexity_check_and_warn(), complexity_fprint(), complexity_scalar_mult(), controls_to_hash_table(), DENOMINATOR, f(), f2(), FA, float_matrice_inversion(), fprintf(), get_debug_level(), hash_get(), hash_pointer, hash_table_free(), hash_table_make(), make_zero_complexity(), malloc(), matrice_fprint(), matrice_free, matrice_identite(), matrice_new, matrice_substract(), MAX_CONTROLS_IN_UNSTRUCTURED, pips_internal_error, trace_off(), trace_on(), unstructured_control, and VALUE_TO_FLOAT.

Referenced by instruction_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

update_statement_complexity()

void update_statement_complexity	(	statement	,
		complexity
	)

variable_local_name()

char* variable_local_name

(

Variable

var

)

Parameters

var

ar

Definition at line 95 of file polynome_ri.c.

{
    string s = NULL;
 
    if (var == TCST) 
        s = strdup(TCST_NAME);
    /*
    else if (var == UNKNOWN_VARIABLE) 
        s = strdup(UNKNOWN_VARIABLE_NAME);
    else if (var == UNKNOWN_RANGE) 
        s = strdup(UNKNOWN_RANGE_NAME);
        */
    else if (var == (Variable) chunk_undefined) 
        pips_internal_error("unexpected var == chunk_undefined.");
    else {
      // s = strdup(entity_local_name((entity) var));
        s = strdup(entity_minimal_name((entity) var));
    }
 
    return (s);
}

References chunk_undefined, entity_minimal_name(), pips_internal_error, strdup(), TCST, and TCST_NAME.

Referenced by complexity_sprint(), final_statement_to_complexity_evaluation(), is_inferior_pvarval(), is_inferior_var(), and is_inferior_varval().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_name()

char* variable_name

(

Variable

var

)

polynome_ri.c

This file gathers some functions interfacing polynomial library and the RI.

The "Variable" type used by polynomials is casted to "entity", the "Value" type, to int.

char *variable_name(Variable var) return the complete name of the entity var

char *variable_local_name(Variable var) return the abbreviated, local name of var

bool is_inferior_var(Variable var1, var2) return true if the complete name of var1 is lexicographically before var2's one.

Variable name_to_variable(char *name) inverse function of variable_name. name must be the complete name of the variable. Modif: – entity_local_name is replaced by module_local_name. LZ 230993

FI: no longer useful

Parameters

var

ar

Definition at line 73 of file polynome_ri.c.

{
    string s = (string) malloc(10);
 
    if (var == TCST) 
        s = strdup(TCST_NAME);
    /* FI: no longer useful */
    /*
    else if (var == UNKNOWN_VARIABLE) 
        s = strdup(UNKNOWN_VARIABLE_NAME);
    else if (var == UNKNOWN_RANGE) 
        s = strdup(UNKNOWN_RANGE_NAME);
        */
    else if (var == (Variable) chunk_undefined) 
        pips_internal_error("unexpected var == chunk_undefined.");
    else 
        s = strdup(entity_name((entity) var));
 
    return (s);
}

whileloop_to_complexity()

complexity whileloop_to_complexity	(	whileloop	while_instr,
		transformer	precond,
		list	effects_list
	)

5th element of instruction

Parameters

while_instr	hile_instr
precond	recond
effects_list	ffects_list

Definition at line 692 of file comp_scan.c.

{
    basic b;
    expression exp1, exp2,exp3;
    expression exp = whileloop_condition(while_instr);
    complexity range ;
    complexity cbody = statement_to_complexity(whileloop_body(while_instr), precond, effects_list),
      ctest = expression_to_complexity(exp, &b,precond, effects_list);
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
        fprintf(stderr, "\n");
        fprintf(stderr, "YYY  body  complexity: ");
        complexity_fprint(stderr, cbody, false, true);
        fprintf(stderr, "YYY  test complexity: ");
        complexity_fprint(stderr, ctest, false, true);
    }
    
    syntax              s        = expression_syntax( exp );
    entity              fun      = call_function(syntax_call( s ));
    if (ENTITY_LESS_THAN_P( fun )) {
      exp1 = EXPRESSION(CAR( call_arguments(syntax_call(expression_syntax( exp )))));
      exp2 = EXPRESSION(CAR(CDR( call_arguments(syntax_call(expression_syntax( exp ))))));
      exp3 = make_op_exp( MINUS_OPERATOR_NAME,exp1,exp2);
      range = expression_to_complexity_polynome(exp3,
                                                precond, effects_list, 
                                                KEEP_SYMBOLS, MINIMUM_VALUE);
    }
    else
      {
        range = make_complexity_unknown(UNKNOWN_RANGE_NAME);
      }
    complexity_add(&cbody,ctest);
    complexity_mult(&cbody,range);
    
    if (get_bool_property("COMPLEXITY_INTERMEDIATES")) {
      fprintf(stderr, "YYY  while total complexity: ");
        complexity_fprint(stderr, cbody, true, true);
        fprintf(stderr, "\n");
    }
    complexity_check_and_warn(__FUNCTION__, cbody);
 
    return cbody;
}

References call_arguments, call_function, CAR, CDR, complexity_add(), complexity_check_and_warn(), complexity_fprint(), complexity_mult(), ENTITY_LESS_THAN_P, exp, EXPRESSION, expression_syntax, expression_to_complexity(), expression_to_complexity_polynome(), fprintf(), get_bool_property(), KEEP_SYMBOLS, make_complexity_unknown(), make_op_exp(), MINIMUM_VALUE, MINUS_OPERATOR_NAME, statement_to_complexity(), syntax_call, UNKNOWN_RANGE_NAME, whileloop_body, and whileloop_condition.

Referenced by instruction_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

hash_callee_to_complexity

hash_table hash_callee_to_complexity

extern

cproto-generated files

comp_scan.c

cproto-generated files

scan a ri expression and try to make a polynomial of it Modif: – entity_local_name is replaced by module_local_name. LZ 230993 – MAXINT replaced by INT_MAX, -MAXINT by INT_MIN FI 1/12/95 useful, pips_error is defined there

Definition at line 57 of file comp_scan.c.

Referenced by any_complexities(), and call_to_complexity().

hash_complexity_parameters

hash_table hash_complexity_parameters

extern

Definition at line 58 of file comp_scan.c.

Referenced by any_complexities(), and loop_to_complexity().

intrinsic_cost_table

intrinsic_cost_record intrinsic_cost_table[]

extern

The table intrinsic_cost_table[] gathers cost information of each intrinsic's cost; those costs are dynamically loaded from user files.

It also returns the "minimum" type of the result of each intrinsic, specified by its basic_tag and number of memory bytes. ("bigger" and "minimum" refer to the order relation defined in the routine "is_inferior_basic"; the tag is_basic_overloaded is used as a don't care tag) (ex: SIN has a type of FLOAT even if its arg is an INT)

Modif: – LOOP_OVERHEAD and CALL_OVERHEAD are added, 280993 LZ – LOOP_OVERHEAD is divided into two: INIT and BRAANCH 081093 LZ

Definition at line 286 of file comp_util.c.

Referenced by fprint_cost_table(), intrinsic_cost(), and load_cost_file().