X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fstat%2Fpattern.c;h=8e7cf8afbd25818431349cd8df38dcd416f69372;hb=cd51c273d337e69ee1a8f120e74cc0d8c785fb93;hp=9a27807f12cfa5223c6f461aaebb4fd49a3b7367;hpb=1580176436dd0df7f1a0b608aef904d5f6d24e5a;p=libfirm diff --git a/ir/stat/pattern.c b/ir/stat/pattern.c index 9a27807f1..8e7cf8afb 100644 --- a/ir/stat/pattern.c +++ b/ir/stat/pattern.c @@ -3,6 +3,7 @@ */ #include #include +#include #include "ident.h" #include "irnode_t.h" @@ -45,6 +46,7 @@ enum vlc_code_t { VLC_32BIT = 0xF0, /**< 40 bit code, carrying 32 bits payload */ VLC_TAG_FIRST = 0xF1, /**< first possible tag value */ + VLC_TAG_ICONST = 0xFB, /**< encodes an integer constant */ VLC_TAG_EMPTY = 0xFC, /**< encodes an empty entity */ VLC_TAG_OPTION = 0xFD, /**< options exists */ VLC_TAG_REF = 0xFE, /**< special tag, next code is an ID */ @@ -55,17 +57,18 @@ enum vlc_code_t { * An entry for patterns */ typedef struct _pattern_entry_t { - counter_t count; /**< amount of pattern occurance */ - unsigned len; /**< lenght of the VLC encoded buffer */ - BYTE buf[1]; /**< buffer contains the VLC encoded pattern */ + counter_t count; /**< amount of pattern occurance */ + unsigned len; /**< length of the VLC encoded buffer */ + BYTE buf[1]; /**< buffer contains the VLC encoded pattern */ } pattern_entry_t; /** * current options */ enum options_t { - OPT_WITH_MODE = 0x00000001, /**< use modes */ - OPT_ENC_GRAPH = 0x00000002, /**< encode graphs, not terms */ + OPT_WITH_MODE = 0x00000001, /**< use modes */ + OPT_ENC_GRAPH = 0x00000002, /**< encode graphs, not terms */ + OPT_WITH_ICONST = 0x00000004, /**< encode integer constants */ }; @@ -73,11 +76,11 @@ enum options_t { * pattern info */ typedef struct _pattern_info_t { - int enable; /**< if non-zero, this module is enabled */ - struct obstack obst; /**< obstack containing the counters */ - HASH_MAP(pattern_entry_t) *pattern_hash; /**< hash map containing the counter for pattern */ - unsigned bound; /**< lowest value for output */ - unsigned options; /**< option mask */ + int enable; /**< if non-zero, this module is enabled */ + struct obstack obst; /**< obstack containing the counters */ + HASH_MAP(pattern_entry_t) *pattern_hash; /**< hash map containing the counter for pattern */ + unsigned bound; /**< lowest value for output */ + unsigned options; /**< option mask */ } pattern_info_t; /* @@ -86,7 +89,7 @@ typedef struct _pattern_info_t { static pattern_info_t _status, *status = &_status; /** - * compare two elemnts for counter + * compare two elements for counter */ static int pattern_count_cmp(const void *elt, const void *key) { @@ -117,7 +120,7 @@ static int pattern_cmp(const void *elt, const void *key) } /** - * initialise a code buffer + * initialize a code buffer */ static void init_buf(CODE_BUFFER *buf, BYTE *data, unsigned len) { @@ -141,7 +144,7 @@ static INLINE void put_byte(CODE_BUFFER *buf, BYTE byte) } /** - * returns the current lenght of a buffer + * returns the current length of a buffer */ static unsigned buf_lenght(const CODE_BUFFER *buf) { @@ -149,7 +152,7 @@ static unsigned buf_lenght(const CODE_BUFFER *buf) } /** - * returns the current lenght of a buffer + * returns the current length of a buffer */ static const BYTE *buf_content(const CODE_BUFFER *buf) { @@ -311,20 +314,19 @@ static int addr_cmp(const void *p1, const void *p2, size_t size) { return e1->addr != e2->addr; } -/* +/** * encodes an IR-node, recursive worker + * + * @return reached depth */ -static void _encode_node(ir_node *node, int max_depth, codec_env_t *env) +static int _encode_node(ir_node *node, int max_depth, codec_env_t *env) { addr_entry_t entry, *r_entry; set_entry *s_entry; int i, preds; + int res, depth; -#if 0 opcode code = get_irn_opcode(node); -#else - ir_op *code = get_irn_op(node); -#endif /* insert the node into our ID map */ entry.addr = node; @@ -338,7 +340,7 @@ static void _encode_node(ir_node *node, int max_depth, codec_env_t *env) put_tag(env->buf, VLC_TAG_REF); put_code(env->buf, r_entry->id); - return; + return max_depth; } else { /* a new entry, proceed */ @@ -347,6 +349,7 @@ static void _encode_node(ir_node *node, int max_depth, codec_env_t *env) put_code(env->buf, (unsigned)code); + /* do we need the mode ? */ if (env->options & OPT_WITH_MODE) { ir_mode *mode = get_irn_mode(node); @@ -356,29 +359,54 @@ static void _encode_node(ir_node *node, int max_depth, codec_env_t *env) put_tag(env->buf, VLC_TAG_EMPTY); } + /* do we need integer constants */ + if (env->options & OPT_WITH_ICONST) { + if (code == iro_Const) { + tarval *tv = get_Const_tarval(node); + + if (tarval_is_long(tv)) { + long v = get_tarval_long(tv); + + put_tag(env->buf, VLC_TAG_ICONST); + put_code(env->buf, v); + } + } + } + --max_depth; if (max_depth <= 0) { put_code(env->buf, 0); - return; + return max_depth; } preds = get_irn_arity(node); put_code(env->buf, preds); + res = INT_MAX; for (i = 0; i < preds; ++i) { ir_node *n = get_irn_n(node, i); - _encode_node(n, max_depth, env); + depth = _encode_node(n, max_depth, env); + if (depth < res) + res = depth; } + return res; } /** - * encode an IR-node - */ -static void encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth) + * encode an IR-node (and its children) + * + * @param @node The root node of the graph + * @param buf The code buffer to store the bitstring in + * @param max_depth The maximum depth for descending + * + * @return The depth of the encoded graph (without cycles) + */ +static int encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth) { codec_env_t env; + int res; env.buf = buf; env.curr_id = 1; /* 0 is used for special purpose */ @@ -396,10 +424,12 @@ static void encode_node(ir_node *node, CODE_BUFFER *buf, int max_depth) put_code(buf, env.options); } - _encode_node(node, max_depth, &env); + res = _encode_node(node, max_depth, &env); if (env.options & OPT_ENC_GRAPH) del_set(env.id_set); + + return max_depth - res; } /** @@ -410,14 +440,23 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env) unsigned code; unsigned op_code; unsigned mode_code = 0; + long iconst; + void *attr = NULL; code = next_tag(env->buf); if (code == VLC_TAG_REF) { /* it's a REF */ code = get_code(env->buf); /* dump the edge */ - if (parent) - pattern_dump_edge(env->dmp, code, parent, position); + if (parent) { + int edge_mode = 0; + /* + * the mode of a Firm edge can be either computed from its target or + * from its source and position. We must take the second approach because + * we dont know the target here, it's a ref. + */ + pattern_dump_edge(env->dmp, code, parent, position, edge_mode); + } /* dump the node ref */ pattern_dump_ref(env->dmp, code); @@ -435,13 +474,27 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env) } } + /* check, if a ICONST attribute is given */ + if (next_tag(env->buf) == VLC_TAG_ICONST) { + iconst = get_code(env->buf); + attr = &iconst; + } + /* dump the edge */ - if (parent) - pattern_dump_edge(env->dmp, env->curr_id, parent, position); + if (parent) { + int edge_mode = 0; + + /* + * the mode of a Firm edge can be either computed from its target or + * from its source and position. We take the second approach because + * we need it anyway for ref's. + */ + pattern_dump_edge(env->dmp, env->curr_id, parent, position, edge_mode); + } /* dump the node */ parent = env->curr_id; - pattern_dump_node(env->dmp, parent, op_code, mode_code); + pattern_dump_node(env->dmp, parent, op_code, mode_code, attr); /* ok, we have a new ID */ ++env->curr_id; @@ -465,7 +518,7 @@ static void _decode_node(unsigned parent, int position, codec_env_t *env) /** * decode an IR-node */ -static void decode_node(BYTE *b, unsigned len) +static void decode_node(BYTE *b, unsigned len, pattern_dumper_t *dump) { codec_env_t env; CODE_BUFFER buf; @@ -475,7 +528,7 @@ static void decode_node(BYTE *b, unsigned len) env.buf = &buf; env.curr_id = 1; /* 0 is used for special purpose */ - env.dmp = &stdout_dump; + env.dmp = dump; /* decode options */ code = next_tag(&buf); @@ -531,22 +584,28 @@ static void calc_nodes_pattern(ir_node *node, void *ctx) pattern_env_t *env = ctx; CODE_BUFFER buf; pattern_entry_t *entry; + int depth; init_buf(&buf, buffer, sizeof(buffer)); - encode_node(node, &buf, env->max_depth); + depth = encode_node(node, &buf, env->max_depth); - entry = pattern_get_entry(&buf, status->pattern_hash); + /* ignore single node pattern (i.e. constants) */ + if (depth > 1) { + entry = pattern_get_entry(&buf, status->pattern_hash); - /* increase count */ - cnt_inc(&entry->count); + /* increase count */ + cnt_inc(&entry->count); + } } /** + * output the collected pattern */ static void pattern_output(void) { - pattern_entry_t *entry; - pattern_entry_t **pattern_arr; + pattern_entry_t *entry; + pattern_entry_t **pattern_arr; + pattern_dumper_t *dump; int i, count = pset_count(status->pattern_hash); printf("\n%d pattern detected\n", count); @@ -554,6 +613,9 @@ static void pattern_output(void) if (count <= 0) return; + /* creates a dumper */ + dump = new_vcg_dumper("pattern.vcg", 100); + pattern_arr = xmalloc(sizeof(*pattern_arr) * count); for (i = 0, entry = pset_first(status->pattern_hash); entry && i < count; @@ -571,10 +633,14 @@ static void pattern_output(void) if (entry->count.cnt[0] < status->bound) continue; - printf("%8d\t", entry->count.cnt[0]); - decode_node(entry->buf, entry->len); - printf("\n"); + /* dump a pattern */ + pattern_dump_new_pattern(dump, &entry->count); + decode_node(entry->buf, entry->len, dump); + pattern_dump_finish_pattern(dump); } + + /* destroy it */ + pattern_end(dump); } /* @@ -591,12 +657,12 @@ void stat_calc_pattern_history(ir_graph *irg) if (irg == get_const_code_irg()) return; - env.max_depth = 4; + env.max_depth = 5; irg_walk_graph(irg, calc_nodes_pattern, NULL, &env); } /* - * initialises the pattern history + * initializes the pattern history */ void stat_init_pattern_history(int enable) { @@ -604,8 +670,8 @@ void stat_init_pattern_history(int enable) if (! enable) return; - status->bound = 3; - status->options = OPT_WITH_MODE | OPT_ENC_GRAPH; + status->bound = 10; + status->options = OPT_WITH_MODE | OPT_ENC_GRAPH | OPT_WITH_ICONST; obstack_init(&status->obst);