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;
+}