Callgrind merge: code
git-svn-id: svn://svn.valgrind.org/valgrind/trunk@5780 a5019735-40e9-0310-863c-91ae7b9d1cf9
diff --git a/callgrind/events.c b/callgrind/events.c
new file mode 100644
index 0000000..6ef8d85
--- /dev/null
+++ b/callgrind/events.c
@@ -0,0 +1,575 @@
+/*--------------------------------------------------------------------*/
+/*--- Callgrind ---*/
+/*--- events.c ---*/
+/*--------------------------------------------------------------------*/
+
+/*
+ This file is part of Callgrind, a Valgrind tool for call tracing.
+
+ Copyright (C) 2002-2004, Josef Weidendorfer (Josef.Weidendorfer@gmx.de)
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307, USA.
+
+ The GNU General Public License is contained in the file COPYING.
+*/
+
+#include "global.h"
+
+#define MAX_EVENTTYPE 20
+
+static EventType eventtype[MAX_EVENTTYPE];
+static Int eventtype_count = 0;
+
+EventType* CLG_(register_eventtype)(Char* name)
+{
+ EventType* et;
+
+ if (eventtype_count == MAX_EVENTTYPE) {
+ VG_(printf)("\nMore than %d event types used!\n"
+ "Increase MAX_EVENTTYPE in ct_events.c and recomile this tool!\n",
+ MAX_EVENTTYPE);
+ VG_(tool_panic)("Too many event types requested.");
+ }
+
+ et = &(eventtype[eventtype_count]);
+ et->id = eventtype_count;
+ et->name = (UChar*) VG_(strdup)(name);
+ et->description = 0;
+
+ eventtype_count++;
+
+ return et;
+}
+
+
+EventType* CLG_(get_eventtype)(Char* name)
+{
+ Int i;
+
+ for(i=0;i<eventtype_count;i++)
+ if (VG_(strcmp)(eventtype[i].name, name) == 0)
+ return eventtype+i;
+ return 0;
+}
+
+EventType* CLG_(get_eventtype_byindex)(Int id)
+{
+ if ((id >= 0) && (id < eventtype_count))
+ return eventtype+id;
+ return 0;
+}
+
+/* Allocate space for an event set */
+EventSet* CLG_(get_eventset)(Char* n, Int capacity)
+{
+ EventSet* es;
+
+ es = (EventSet*) CLG_MALLOC(sizeof(EventSet) +
+ capacity * sizeof(EventSetEntry));
+ es->capacity = capacity;
+ es->size = 0;
+ es->name = n;
+
+ return es;
+}
+
+/* Incorporate a event type into a set, get start offset */
+Int CLG_(add_eventtype)(EventSet* es, EventType* t)
+{
+ Int offset = es->size;
+ if (es->capacity - offset < 1) return -1;
+
+ es->size++;
+ es->e[offset].type = t;
+ es->e[offset].nextTop = es->size;
+
+ return offset;
+}
+
+/* Incorporate one event set into another, get start offset */
+Int CLG_(add_eventset)(EventSet* dst, EventSet* src)
+{
+ Int offset = dst->size, i;
+ if (!src || (src->size == 0)) return offset;
+
+ if (dst->capacity - offset < src->size) return -1;
+
+ for(i=0;i<src->size;i++) {
+ dst->e[offset+i].type = src->e[i].type;
+ dst->e[offset+i].nextTop = src->e[i].nextTop + offset;
+ }
+ dst->size += src->size;
+
+ return offset;
+}
+
+/* Incorporate two event types into a set, with second < first */
+Int CLG_(add_dep_event2)(EventSet* es, EventType* e1, EventType* e2)
+{
+ Int offset = es->size;
+
+ if (es->capacity - offset < 2) return -1;
+
+ es->size += 2;
+ es->e[offset].type = e1;
+ es->e[offset].nextTop = es->size;
+ es->e[offset+1].type = e2;
+ es->e[offset+1].nextTop = es->size;
+
+ return offset;
+}
+
+/* Incorporate 3 event types into a set, with third < second < first */
+Int CLG_(add_dep_event3)(EventSet* es,
+ EventType* e1, EventType* e2, EventType* e3)
+{
+ Int offset = es->size;
+
+ if (es->capacity - offset < 3) return -1;
+
+ es->size += 3;
+ es->e[offset].type = e1;
+ es->e[offset].nextTop = es->size;
+ es->e[offset+1].type = e2;
+ es->e[offset+1].nextTop = es->size;
+ es->e[offset+2].type = e3;
+ es->e[offset+2].nextTop = es->size;
+
+ return offset;
+}
+
+Int CLG_(add_dep_event4)(EventSet* es,
+ EventType* e1, EventType* e2,
+ EventType* e3, EventType* e4)
+{
+ Int offset = es->size;
+
+ if (es->capacity - offset < 4) return -1;
+
+ es->size += 4;
+ es->e[offset].type = e1;
+ es->e[offset].nextTop = es->size;
+ es->e[offset+1].type = e2;
+ es->e[offset+1].nextTop = es->size;
+ es->e[offset+2].type = e3;
+ es->e[offset+2].nextTop = es->size;
+ es->e[offset+3].type = e4;
+ es->e[offset+3].nextTop = es->size;
+
+ return offset;
+}
+
+/* Returns number of characters written */
+Int CLG_(sprint_eventset)(Char* buf, EventSet* es)
+{
+ Int i, pos = 0;
+
+ for(i=0; i< es->size; i++) {
+ if (pos>0) buf[pos++] = ' ';
+ pos += VG_(sprintf)(buf + pos, es->e[i].type->name);
+ }
+ buf[pos] = 0;
+
+ return pos;
+}
+
+/* Get cost array for an event set */
+ULong* CLG_(get_eventset_cost)(EventSet* es)
+{
+ return CLG_(get_costarray)(es->capacity);
+}
+
+/* Set all costs of an event set to zero */
+void CLG_(init_cost)(EventSet* es, ULong* cost)
+{
+ Int i;
+
+ if (!cost) return;
+
+ for(i=0;i<es->capacity;i++)
+ cost[i] = 0;
+}
+
+/* Set all costs of an event set to zero */
+void CLG_(init_cost_lz)(EventSet* es, ULong** cost)
+{
+ Int i;
+
+ CLG_ASSERT(cost != 0);
+ if (!(*cost))
+ *cost = CLG_(get_eventset_cost)(es);
+
+ for(i=0;i<es->capacity;i++)
+ (*cost)[i] = 0;
+}
+
+void CLG_(zero_cost)(EventSet* es, ULong* cost)
+{
+ Int i;
+
+ if (!cost) return;
+
+ for(i=0;i<es->size;i++)
+ cost[i] = 0;
+}
+
+Bool CLG_(is_zero_cost)(EventSet* es, ULong* cost)
+{
+ Int i = 0;
+
+ if (!cost) return True;
+
+ while(i<es->size) {
+ if (cost[i] != 0) return False;
+ i = es->e[i].nextTop;
+ }
+ return True;
+}
+
+Bool CLG_(is_equal_cost)(EventSet* es, ULong* c1, ULong* c2)
+{
+ Int i = 0;
+
+ if (!c1) return CLG_(is_zero_cost)(es,c2);
+ if (!c2) return CLG_(is_zero_cost)(es,c1);
+
+ while(i<es->size) {
+ if (c1[i] != c2[i]) return False;
+ if (c1[i] == 0)
+ i = es->e[i].nextTop;
+ else
+ i++;
+ }
+ return True;
+}
+
+void CLG_(copy_cost)(EventSet* es, ULong* dst, ULong* src)
+{
+ Int i;
+
+ if (!src) {
+ CLG_(zero_cost)(es, dst);
+ return;
+ }
+ CLG_ASSERT(dst != 0);
+
+ for(i=0;i<es->size;i++)
+ dst[i] = src[i];
+}
+
+void CLG_(copy_cost_lz)(EventSet* es, ULong** pdst, ULong* src)
+{
+ Int i;
+ ULong* dst;
+
+ CLG_ASSERT(pdst != 0);
+
+ if (!src) {
+ CLG_(zero_cost)(es, *pdst);
+ return;
+ }
+ dst = *pdst;
+ if (!dst)
+ dst = *pdst = CLG_(get_eventset_cost)(es);
+
+ for(i=0;i<es->size;i++)
+ dst[i] = src[i];
+}
+
+void CLG_(add_cost)(EventSet* es, ULong* dst, ULong* src)
+{
+ Int i = 0;
+
+ if (!src) return;
+ CLG_ASSERT(dst != 0);
+
+ while(i<es->size) {
+ if (src[i] == 0)
+ i = es->e[i].nextTop;
+ else {
+ dst[i] += src[i];
+ i++;
+ }
+ }
+}
+
+void CLG_(add_cost_lz)(EventSet* es, ULong** pdst, ULong* src)
+{
+ Int i;
+ ULong* dst;
+
+ if (!src) return;
+ CLG_ASSERT(pdst != 0);
+
+ dst = *pdst;
+ if (!dst) {
+ dst = *pdst = CLG_(get_eventset_cost)(es);
+ CLG_(copy_cost)(es,dst,src);
+ return;
+ }
+
+ i = 0;
+ while(i<es->size) {
+ if (src[i] == 0)
+ i = es->e[i].nextTop;
+ else {
+ dst[i] += src[i];
+ i++;
+ }
+ }
+}
+
+/* Adds src to dst and zeros src. Returns false if nothing changed */
+Bool CLG_(add_and_zero_cost)(EventSet* es, ULong* dst, ULong* src)
+{
+ Int i = 0, j = 0;
+
+ CLG_DEBUGIF(6) {
+ CLG_DEBUG(6, " add_and_zero_cost(%s, dst %p, src %p)\n", es->name, dst, src);
+ CLG_(print_cost)(-5, es, src);
+ }
+
+ if (!es || !src) return False;
+
+ while(i<es->size) {
+ if (src[i] == 0)
+ i = es->e[i].nextTop;
+ else {
+ dst[i] += src[i];
+ src[i] = 0;
+ i++;
+ j++;
+ }
+ }
+
+ return (j>0);
+}
+
+/* Adds src to dst and zeros src. Returns false if nothing changed */
+Bool CLG_(add_and_zero_cost_lz)(EventSet* es, ULong** pdst, ULong* src)
+{
+ Int i;
+ ULong* dst;
+
+ if (!src) return False;
+
+ i = 0;
+ while(1) {
+ if (i >= es->size) return False;
+ if (src[i] != 0) break;
+ i = es->e[i].nextTop;
+ }
+
+ CLG_ASSERT(pdst != 0);
+ dst = *pdst;
+ if (!dst) {
+ dst = *pdst = CLG_(get_eventset_cost)(es);
+ CLG_(copy_cost)(es,dst,src);
+ CLG_(zero_cost)(es,src);
+ return True;
+ }
+
+ dst[i] += src[i];
+ src[i] = 0;
+ i++;
+
+ while(i<es->size) {
+ if (src[i] == 0)
+ i = es->e[i].nextTop;
+ else {
+ dst[i] += src[i];
+ src[i] = 0;
+ }
+ }
+
+ return True;
+}
+
+/* Adds difference of new and old to dst, and set old to new.
+ * Returns false if nothing changed */
+Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new)
+{
+ Int i = 0, j = 0;
+
+ while(i<es->size) {
+ if (new[i] == old[i])
+ i = es->e[i].nextTop;
+ else {
+ dst[i] += new[i] - old[i];
+ old[i] = new[i];
+ i++;
+ j++;
+ }
+ }
+
+ return (j>0);
+}
+
+/* Adds difference of new and old to dst, and set old to new.
+ * Returns false if nothing changed */
+Bool CLG_(add_diff_cost_lz)(EventSet* es, ULong** pdst,
+ ULong* old, ULong* new)
+{
+ Int i;
+ ULong* dst;
+
+ if (!old && !new) return False;
+ CLG_ASSERT(old && new);
+
+ i = 0;
+ while(1) {
+ if (i >= es->size) return False;
+ if (old[i] != new[i]) break;
+ i = es->e[i].nextTop;
+ }
+
+ CLG_ASSERT(pdst != 0);
+ dst = *pdst;
+ if (!dst) {
+ dst = *pdst = CLG_(get_eventset_cost)(es);
+ CLG_(zero_cost)(es,dst);
+ }
+
+ dst[i] += new[i] - old[i];
+ old[i] = new[i];
+ i++;
+
+ while(i<es->size) {
+ if (new[i] == old[i])
+ i = es->e[i].nextTop;
+ else {
+ dst[i] += new[i] - old[i];
+ old[i] = new[i];
+ i++;
+ }
+ }
+
+ return True;
+}
+
+/* Returns number of characters written */
+Int CLG_(sprint_cost)(Char* buf, EventSet* es, ULong* c)
+{
+ Int i, pos, skipped = 0;
+
+ if (!c || es->size==0) return 0;
+
+ /* At least one entry */
+ pos = VG_(sprintf)(buf, "%llu", c[0]);
+ i = 1;
+
+ while(i<es->size) {
+ if (c[i] == 0) {
+ skipped += es->e[i].nextTop - i;
+ i = es->e[i].nextTop;
+ }
+ else {
+ while(skipped>0) {
+ buf[pos++] = ' ';
+ buf[pos++] = '0';
+ skipped--;
+ }
+ buf[pos++] = ' ';
+ pos += VG_(sprintf)(buf+pos, "%llu", c[i]);
+ i++;
+ }
+ }
+
+ return pos;
+}
+
+
+/* Allocate space for an event mapping */
+EventMapping* CLG_(get_eventmapping)(EventSet* es)
+{
+ EventMapping* em;
+
+ CLG_ASSERT(es != 0);
+
+ em = (EventMapping*) CLG_MALLOC(sizeof(EventMapping) +
+ es->capacity * sizeof(Int));
+ em->capacity = es->capacity;
+ em->size = 0;
+ em->set = es;
+
+ return em;
+}
+
+void CLG_(append_event)(EventMapping* em, Char* n)
+{
+ Int i;
+
+ CLG_ASSERT(em != 0);
+
+ for(i=0; i<em->set->size; i++)
+ if (VG_(strcmp)(n, em->set->e[i].type->name)==0)
+ break;
+
+ if (i == em->set->size) return;
+
+ CLG_ASSERT(em->capacity > em->size);
+
+ em->index[em->size] = i;
+ em->size++;
+}
+
+
+/* Returns number of characters written */
+Int CLG_(sprint_eventmapping)(Char* buf, EventMapping* em)
+{
+ Int i, pos = 0;
+
+ CLG_ASSERT(em != 0);
+
+ for(i=0; i< em->size; i++) {
+ if (pos>0) buf[pos++] = ' ';
+ pos += VG_(sprintf)(buf + pos, em->set->e[em->index[i]].type->name);
+ }
+ buf[pos] = 0;
+
+ return pos;
+}
+
+/* Returns number of characters written */
+Int CLG_(sprint_mappingcost)(Char* buf, EventMapping* em, ULong* c)
+{
+ Int i, pos, skipped = 0;
+
+ if (!c || em->size==0) return 0;
+
+ /* At least one entry */
+ pos = VG_(sprintf)(buf, "%llu", c[em->index[0]]);
+ i = 1;
+
+ while(i<em->size) {
+ if (c[em->index[i]] == 0) {
+ skipped++;
+ i++;
+ }
+ else {
+ while(skipped>0) {
+ buf[pos++] = ' ';
+ buf[pos++] = '0';
+ skipped--;
+ }
+ buf[pos++] = ' ';
+ pos += VG_(sprintf)(buf+pos, "%llu", c[em->index[i]]);
+ i++;
+ }
+ }
+
+ return pos;
+}