callgrind/events.c

   1 /*--------------------------------------------------------------------*/
   2 /*--- Callgrind                                                    ---*/
   3 /*---                                                     events.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Callgrind, a Valgrind tool for call tracing.
   8
   9    Copyright (C) 2002-2013, Josef Weidendorfer (Josef.Weidendorfer@gmx.de)
  10
  11    This program is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU General Public License as
  13    published by the Free Software Foundation; either version 2 of the
  14    License, or (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful, but
  17    WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19    General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  24    02111-1307, USA.
  25
  26    The GNU General Public License is contained in the file COPYING.
  27 */
  28
  29 #include "global.h"
  30
  31 /* This should be 2**MAX_EVENTGROUP_COUNT */
  32 #define MAX_EVENTSET_COUNT 1024
  33
  34 static EventGroup* eventGroup[MAX_EVENTGROUP_COUNT];
  35 static EventSet* eventSetTable[MAX_EVENTSET_COUNT];
  36 static Bool eventSets_initialized = 0;
  37
  38 static
  39 void initialize_event_sets(void)
  40 {
  41     Int i;
  42
  43     if (eventSets_initialized) return;
  44
  45     for(i=0; i< MAX_EVENTGROUP_COUNT; i++)
  46         eventGroup[i] = 0;
  47
  48     for(i=0; i< MAX_EVENTSET_COUNT; i++)
  49         eventSetTable[i] = 0;
  50
  51     eventSets_initialized = 1;
  52  }
  53
  54 static
  55 EventGroup* new_event_group(int id, int n)
  56 {
  57     EventGroup* eg;
  58
  59     initialize_event_sets();
  60
  61     CLG_ASSERT(id>=0 && id<MAX_EVENTGROUP_COUNT);
  62     CLG_ASSERT(eventGroup[id]==0);
  63
  64     eg = (EventGroup*) CLG_MALLOC("cl.events.group.1",
  65                                   sizeof(EventGroup) + n * sizeof(HChar*));
  66     eg->size = n;
  67     eventGroup[id] = eg;
  68     return eg;
  69 }
  70
  71 EventGroup* CLG_(register_event_group) (int id, const HChar* n1)
  72 {
  73     EventGroup* eg = new_event_group(id, 1);
  74     eg->name[0] = n1;
  75
  76     return eg;
  77 }
  78
  79 EventGroup* CLG_(register_event_group2)(int id, const HChar* n1,
  80                                         const HChar* n2)
  81 {
  82     EventGroup* eg = new_event_group(id, 2);
  83     eg->name[0] = n1;
  84     eg->name[1] = n2;
  85
  86     return eg;
  87 }
  88
  89 EventGroup* CLG_(register_event_group3)(int id, const HChar* n1,
  90                                         const HChar* n2, const HChar* n3)
  91 {
  92     EventGroup* eg = new_event_group(id, 3);
  93     eg->name[0] = n1;
  94     eg->name[1] = n2;
  95     eg->name[2] = n3;
  96
  97     return eg;
  98 }
  99
 100 EventGroup* CLG_(register_event_group4)(int id, const HChar* n1,
 101                                         const HChar* n2, const HChar* n3,
 102                                         const HChar* n4)
 103 {
 104     EventGroup* eg = new_event_group(id, 4);
 105     eg->name[0] = n1;
 106     eg->name[1] = n2;
 107     eg->name[2] = n3;
 108     eg->name[3] = n4;
 109
 110     return eg;
 111 }
 112
 113 EventGroup* CLG_(get_event_group)(int id)
 114 {
 115     CLG_ASSERT(id>=0 && id<MAX_EVENTGROUP_COUNT);
 116
 117     return eventGroup[id];
 118 }
 119
 120
 121 static
 122 EventSet* eventset_from_mask(UInt mask)
 123 {
 124     EventSet* es;
 125     Int i, count, offset;
 126
 127     if (mask >= MAX_EVENTSET_COUNT) return 0;
 128
 129     initialize_event_sets();
 130     if (eventSetTable[mask]) return eventSetTable[mask];
 131
 132     es = (EventSet*) CLG_MALLOC("cl.events.eventset.1", sizeof(EventSet));
 133     es->mask = mask;
 134
 135     offset = 0;
 136     count = 0;
 137     for(i=0;i<MAX_EVENTGROUP_COUNT;i++) {
 138         es->offset[i] = offset;
 139         if ( ((mask & (1u<<i))==0) || (eventGroup[i]==0))
 140             continue;
 141
 142         offset += eventGroup[i]->size;
 143         count++;
 144     }
 145     es->size = offset;
 146     es->count = count;
 147
 148     eventSetTable[mask] = es;
 149     return es;
 150 }
 151
 152 EventSet* CLG_(get_event_set)(Int id)
 153 {
 154     CLG_ASSERT(id>=0 && id<MAX_EVENTGROUP_COUNT);
 155     return eventset_from_mask(1u << id);
 156 }
 157
 158 EventSet* CLG_(get_event_set2)(Int id1, Int id2)
 159 {
 160     CLG_ASSERT(id1>=0 && id1<MAX_EVENTGROUP_COUNT);
 161     CLG_ASSERT(id2>=0 && id2<MAX_EVENTGROUP_COUNT);
 162     return eventset_from_mask((1u << id1) | (1u << id2));
 163 }
 164
 165 EventSet* CLG_(add_event_group)(EventSet* es, Int id)
 166 {
 167     CLG_ASSERT(id>=0 && id<MAX_EVENTGROUP_COUNT);
 168     if (!es) es = eventset_from_mask(0);
 169     return eventset_from_mask(es->mask | (1u << id));
 170 }
 171
 172 EventSet* CLG_(add_event_group2)(EventSet* es, Int id1, Int id2)
 173 {
 174     CLG_ASSERT(id1>=0 && id1<MAX_EVENTGROUP_COUNT);
 175     CLG_ASSERT(id2>=0 && id2<MAX_EVENTGROUP_COUNT);
 176     if (!es) es = eventset_from_mask(0);
 177     return eventset_from_mask(es->mask | (1u << id1) | (1u << id2));
 178 }
 179
 180 EventSet* CLG_(add_event_set)(EventSet* es1, EventSet* es2)
 181 {
 182     if (!es1) es1 = eventset_from_mask(0);
 183     if (!es2) es2 = eventset_from_mask(0);
 184     return eventset_from_mask(es1->mask | es2->mask);
 185 }
 186
 187
 188 /* Get cost array for an event set */
 189 ULong* CLG_(get_eventset_cost)(EventSet* es)
 190 {
 191     return CLG_(get_costarray)(es->size);
 192 }
 193
 194 /* Set all costs of an event set to zero */
 195 void CLG_(init_cost)(EventSet* es, ULong* cost)
 196 {
 197     Int i;
 198
 199     if (!cost) return;
 200
 201     for(i=0; i<es->size; i++)
 202         cost[i] = 0;
 203 }
 204
 205 /* Set all costs of an event set to zero */
 206 void CLG_(init_cost_lz)(EventSet* es, ULong** cost)
 207 {
 208     Int i;
 209
 210     CLG_ASSERT(cost != 0);
 211     if (!(*cost))
 212         *cost = CLG_(get_eventset_cost)(es);
 213
 214     for(i=0; i<es->size; i++)
 215         (*cost)[i] = 0;
 216 }
 217
 218 void CLG_(zero_cost)(EventSet* es, ULong* cost)
 219 {
 220     Int i;
 221
 222     if (!cost) return;
 223
 224     for(i=0;i<es->size;i++)
 225         cost[i] = 0;
 226 }
 227
 228 Bool CLG_(is_zero_cost)(EventSet* es, ULong* cost)
 229 {
 230     Int i;
 231
 232     if (!cost) return True;
 233
 234     for(i=0; i<es->size; i++)
 235         if (cost[i] != 0) return False;
 236
 237     return True;
 238 }
 239
 240 void CLG_(copy_cost)(EventSet* es, ULong* dst, ULong* src)
 241 {
 242     Int i;
 243
 244     if (!src) {
 245         CLG_(zero_cost)(es, dst);
 246         return;
 247     }
 248     CLG_ASSERT(dst != 0);
 249
 250     for(i=0;i<es->size;i++)
 251         dst[i] = src[i];
 252 }
 253
 254 void CLG_(copy_cost_lz)(EventSet* es, ULong** pdst, ULong* src)
 255 {
 256     Int i;
 257     ULong* dst;
 258
 259     CLG_ASSERT(pdst != 0);
 260
 261     if (!src) {
 262         CLG_(zero_cost)(es, *pdst);
 263         return;
 264     }
 265     dst = *pdst;
 266     if (!dst)
 267         dst = *pdst = CLG_(get_eventset_cost)(es);
 268
 269     for(i=0;i<es->size;i++)
 270         dst[i] = src[i];
 271 }
 272
 273 void CLG_(add_cost)(EventSet* es, ULong* dst, ULong* src)
 274 {
 275     Int i;
 276
 277     if (!src) return;
 278     CLG_ASSERT(dst != 0);
 279
 280     for(i=0; i<es->size; i++)
 281         dst[i] += src[i];
 282 }
 283
 284 void CLG_(add_cost_lz)(EventSet* es, ULong** pdst, ULong* src)
 285 {
 286     Int i;
 287     ULong* dst;
 288
 289     if (!src) return;
 290     CLG_ASSERT(pdst != 0);
 291
 292     dst = *pdst;
 293     if (!dst) {
 294         dst = *pdst = CLG_(get_eventset_cost)(es);
 295         CLG_(copy_cost)(es, dst, src);
 296         return;
 297     }
 298
 299     for(i=0; i<es->size; i++)
 300         dst[i] += src[i];
 301 }
 302
 303 /* Adds src to dst and zeros src. Returns false if nothing changed */
 304 Bool CLG_(add_and_zero_cost)(EventSet* es, ULong* dst, ULong* src)
 305 {
 306     Int i;
 307     Bool is_nonzero = False;
 308
 309     CLG_ASSERT((es != 0) && (dst != 0));
 310     if (!src) return False;
 311
 312     for(i=0; i<es->size; i++) {
 313         if (src[i]==0) continue;
 314         dst[i] += src[i];
 315         src[i] = 0;
 316         is_nonzero = True;
 317     }
 318
 319     return is_nonzero;
 320 }
 321
 322 /* Adds src to dst and zeros src. Returns false if nothing changed */
 323 Bool CLG_(add_and_zero_cost2)(EventSet* esDst, ULong* dst,
 324                               EventSet* esSrc, ULong* src)
 325 {
 326     Int i,j;
 327     Bool is_nonzero = False;
 328     UInt mask;
 329     EventGroup *eg;
 330     ULong *egDst, *egSrc;
 331
 332     CLG_ASSERT((esDst != 0) && (dst != 0) && (esSrc != 0));
 333     if (!src) return False;
 334
 335     for(i=0, mask=1; i<MAX_EVENTGROUP_COUNT; i++, mask=mask<<1) {
 336         if ((esSrc->mask & mask)==0) continue;
 337         if (eventGroup[i] ==0) continue;
 338
 339         /* if src has a subset, dst must have, too */
 340         CLG_ASSERT((esDst->mask & mask)>0);
 341         eg = eventGroup[i];
 342         egSrc = src + esSrc->offset[i];
 343         egDst = dst + esDst->offset[i];
 344         for(j=0; j<eg->size; j++) {
 345             if (egSrc[j]==0) continue;
 346             egDst[j] += egSrc[j];
 347             egSrc[j] = 0;
 348             is_nonzero = True;
 349         }
 350     }
 351
 352     return is_nonzero;
 353 }
 354
 355
 356
 357 /* Adds difference of new and old to dst, and set old to new.
 358  * Returns false if nothing changed */
 359 Bool CLG_(add_diff_cost)(EventSet* es, ULong* dst, ULong* old, ULong* new_cost)
 360 {
 361     Int i;
 362     Bool is_nonzero = False;
 363
 364     CLG_ASSERT((es != 0) && (dst != 0));
 365     CLG_ASSERT(old && new_cost);
 366
 367     for(i=0; i<es->size; i++) {
 368         if (new_cost[i] == old[i]) continue;
 369         dst[i] += new_cost[i] - old[i];
 370         old[i] = new_cost[i];
 371         is_nonzero = True;
 372     }
 373
 374     return is_nonzero;
 375 }
 376
 377 Bool CLG_(add_diff_cost_lz)(EventSet* es, ULong** pdst, ULong* old, ULong* new_cost)
 378 {
 379     Int i;
 380     ULong* dst;
 381     Bool is_nonzero = False;
 382
 383     CLG_ASSERT((es != 0) && (pdst != 0));
 384     CLG_ASSERT(old && new_cost);
 385
 386     dst = *pdst;
 387     if (!dst) {
 388         dst = *pdst = CLG_(get_eventset_cost)(es);
 389         CLG_(zero_cost)(es, dst);
 390     }
 391
 392     for(i=0; i<es->size; i++) {
 393         if (new_cost[i] == old[i]) continue;
 394         dst[i] += new_cost[i] - old[i];
 395         old[i] = new_cost[i];
 396         is_nonzero = True;
 397     }
 398
 399     return is_nonzero;
 400 }
 401
 402
 403 /* Allocate space for an event mapping */
 404 EventMapping* CLG_(get_eventmapping)(EventSet* es)
 405 {
 406     EventMapping* em;
 407
 408     CLG_ASSERT(es != 0);
 409
 410     em = (EventMapping*) CLG_MALLOC("cl.events.geMapping.1",
 411                                     sizeof(EventMapping) +
 412                                     sizeof(struct EventMappingEntry) *
 413                                     es->size);
 414     em->capacity = es->size;
 415     em->size = 0;
 416     em->es = es;
 417
 418     return em;
 419 }
 420
 421 void CLG_(append_event)(EventMapping* em, const HChar* n)
 422 {
 423     Int i, j, offset = 0;
 424     UInt mask;
 425     EventGroup* eg;
 426
 427     CLG_ASSERT(em != 0);
 428     for(i=0, mask=1; i<MAX_EVENTGROUP_COUNT; i++, mask=mask<<1) {
 429         if ((em->es->mask & mask)==0) continue;
 430         if (eventGroup[i] ==0) continue;
 431
 432         eg = eventGroup[i];
 433         for(j=0; j<eg->size; j++, offset++) {
 434             if (VG_(strcmp)(n, eg->name[j])!=0)
 435                     continue;
 436
 437             CLG_ASSERT(em->capacity > em->size);
 438             em->entry[em->size].group = i;
 439             em->entry[em->size].index = j;
 440             em->entry[em->size].offset = offset;
 441             em->size++;
 442             return;
 443         }
 444     }
 445 }
 446
 447
 448 /* Returns pointer to dynamically string. The string will be overwritten
 449    with each invocation. */
 450 HChar *CLG_(eventmapping_as_string)(const EventMapping* em)
 451 {
 452     Int i;
 453     EventGroup* eg;
 454
 455     CLG_ASSERT(em != 0);
 456
 457     XArray *xa = VG_(newXA)(VG_(malloc), "cl.events.emas", VG_(free),
 458                             sizeof(HChar));
 459
 460     for(i=0; i< em->size; i++) {
 461         if (i > 0) {
 462            VG_(xaprintf)(xa, "%c", ' ');
 463         }
 464         eg = eventGroup[em->entry[i].group];
 465         CLG_ASSERT(eg != 0);
 466         VG_(xaprintf)(xa, "%s", eg->name[em->entry[i].index]);
 467     }
 468     VG_(xaprintf)(xa, "%c", '\0');   // zero terminate the string
 469
 470     HChar *buf = VG_(strdup)("cl.events.emas", VG_(indexXA)(xa, 0));
 471     VG_(deleteXA)(xa);
 472
 473     return buf;
 474 }
 475
 476 /* Returns pointer to dynamically allocated string. Caller needs to
 477    VG_(free) it. */
 478 HChar *CLG_(mappingcost_as_string)(const EventMapping* em, const ULong* c)
 479 {
 480     Int i, skipped = 0;
 481
 482     if (!c || em->size==0) return VG_(strdup)("cl.events.mcas", "");
 483
 484     XArray *xa = VG_(newXA)(VG_(malloc), "cl.events.mcas", VG_(free),
 485                             sizeof(HChar));
 486
 487     /* At least one entry */
 488     VG_(xaprintf)(xa, "%llu", c[em->entry[0].offset]);
 489
 490     for(i=1; i<em->size; i++) {
 491         if (c[em->entry[i].offset] == 0) {
 492             skipped++;
 493             continue;
 494         }
 495         while(skipped>0) {
 496             VG_(xaprintf)(xa, " 0");
 497             skipped--;
 498         }
 499         VG_(xaprintf)(xa, " %llu", c[em->entry[i].offset]);
 500     }
 501     VG_(xaprintf)(xa, "%c", '\0');   // zero terminate the string
 502
 503     HChar *buf = VG_(strdup)("cl.events.mas", VG_(indexXA)(xa, 0));
 504     VG_(deleteXA)(xa);
 505
 506     return buf;
 507 }