Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/js/src/devtools/vprof/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 8 kB

Quelle vprof.cpp Sprache: C

/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "VMPI.h"

// Note, this is not supported in configurations with more than one AvmCore
// running in the same process.

#ifdef WIN32
#  include "util/WindowsWrapper.h"
#else
#  define __cdecl
#  include <stdarg.h>
#  include <string.h>
#endif

#include "vprof.h"

#ifndef MIN
#  define MIN(x, y) ((x) <= (y) ? x : y)
#endif
#ifndef MAX
#  define MAX(x, y) ((x) >= (y) ? x : y)
#endif

#ifndef MAXINT
#  define MAXINT int(unsigned(-1) >> 1)
#endif

#ifndef MAXINT64
#  define MAXINT64 int64_t(uint64_t(-1) >> 1)
#endif

#ifndef __STDC_WANT_SECURE_LIB__
#  define sprintf_s(b, size, fmt, ...) sprintf((b), (fmt), __VA_ARGS__)
#endif

#if THREADED
#  define DO_LOCK(lock) \
    Lock(lock);         \
    {
#  define DO_UNLOCK(lock) \
    }                     \
    ;                     \
    Unlock(lock)
#else
#  define DO_LOCK(lock) \
    {                   \
      (void)(lock);
#  define DO_UNLOCK(lock) }
#endif

#if THREAD_SAFE
#  define LOCK(lock) DO_LOCK(lock)
#  define UNLOCK(lock) DO_UNLOCK(lock)
#else
#  define LOCK(lock) \
    {                \
      (void)(lock);
#  define UNLOCK(lock) }
#endif

static entry* entries = nullptr;
static bool notInitialized = true;
static long glock = LOCK_IS_FREE;

#define Lock(lock)                                                         \
  while (_InterlockedCompareExchange(lock, LOCK_IS_TAKEN, LOCK_IS_FREE) == \
         LOCK_IS_TAKEN) {                                                  \
  };
#define Unlock(lock) \
  _InterlockedCompareExchange(lock, LOCK_IS_FREE, LOCK_IS_TAKEN);

#if defined(WIN32)
static void vprof_printf(const char* format, ...) {
  va_list args;
  va_start(args, format);

  char buf[1024];
  vsnprintf(buf, sizeof(buf), format, args);

  va_end(args);

  printf(buf);
  ::OutputDebugStringA(buf);
}
#else
#  define vprof_printf printf
#endif

static inline entry* reverse(entry* s) {
  entry_t e, n, p;

  p = nullptr;
  for (e = s; e; e = n) {
    n = e->next;
    e->next = p;
    p = e;
  }

  return p;
}

static char* f(double d) {
  static char s[80];
  char* p;
  sprintf_s(s, sizeof(s), "%lf", d);
  p = s + VMPI_strlen(s) - 1;
  while (*p == '0') {
    *p = '\0';
    p--;
    if (p == s) break;
  }
  if (*p == '.') *p = '\0';
  return s;
}

static void dumpProfile(void) {
  entry_t e;

  entries = reverse(entries);
  vprof_printf("event avg [min : max] total count\n");
  for (e = entries; e; e = e->next) {
    if (e->count == 0) continue;  // ignore entries with zero count.
    vprof_printf("%s", e->file);
    if (e->line >= 0) {
      vprof_printf(":%d", e->line);
    }
    vprof_printf(" %s [%lld : %lld] %lld %lld ",
                 f(((double)e->sum) / ((double)e->count)),
                 (long long int)e->min, (long long int)e->max,
                 (long long int)e->sum, (long long int)e->count);
    if (e->h) {
      int j = MAXINT;
      for (j = 0; j < e->h->nbins; j++) {
        vprof_printf("(%lld < %lld) ", (long long int)e->h->count[j],
                     (long long int)e->h->lb[j]);
      }
      vprof_printf("(%lld >= %lld) ", (long long int)e->h->count[e->h->nbins],
                   (long long int)e->h->lb[e->h->nbins - 1]);
    }
    if (e->func) {
      int j;
      for (j = 0; j < NUM_EVARS; j++) {
        if (e->ivar[j] != 0) {
          vprof_printf("IVAR%d %d ", j, e->ivar[j]);
        }
      }
      for (j = 0; j < NUM_EVARS; j++) {
        if (e->i64var[j] != 0) {
          vprof_printf("I64VAR%d %lld ", j, (long long int)e->i64var[j]);
        }
      }
      for (j = 0; j < NUM_EVARS; j++) {
        if (e->dvar[j] != 0) {
          vprof_printf("DVAR%d %lf ", j, e->dvar[j]);
        }
      }
    }
    vprof_printf("\n");
  }
  entries = reverse(entries);
}

static inline entry_t findEntry(char* file, int line) {
  for (entry_t e = entries; e; e = e->next) {
    if ((e->line == line) && (VMPI_strcmp(e->file, file) == 0)) {
      return e;
    }
  }
  return nullptr;
}

// Initialize the location pointed to by 'id' to a new value profile entry
// associated with 'file' and 'line', or do nothing if already initialized.
// An optional final argument provides a user-defined probe function.

int initValueProfile(void** id, char* file, int line, ...) {
  DO_LOCK(&glock);
  entry_t e = (entry_t)*id;
  if (notInitialized) {
    atexit(dumpProfile);
    notInitialized = false;
  }

  if (e == nullptr) {
    e = findEntry(file, line);
    if (e) {
      *id = e;
    }
  }

  if (e == nullptr) {
    va_list va;
    e = (entry_t)malloc(sizeof(entry));
    e->lock = LOCK_IS_FREE;
    e->file = file;
    e->line = line;
    e->value = 0;
    e->sum = 0;
    e->count = 0;
    e->min = 0;
    e->max = 0;
    // optional probe function argument
    va_start(va, line);
    e->func = (void(__cdecl*)(void*))va_arg(va, void*);
    va_end(va);
    e->h = nullptr;
    e->genptr = nullptr;
    VMPI_memset(&e->ivar, 0, sizeof(e->ivar));
    VMPI_memset(&e->i64var, 0, sizeof(e->i64var));
    VMPI_memset(&e->dvar, 0, sizeof(e->dvar));
    e->next = entries;
    entries = e;
    *id = e;
  }
  DO_UNLOCK(&glock);

  return 0;
}

// Record a value profile event.

int profileValue(void* id, int64_t value) {
  entry_t e = (entry_t)id;
  long* lock = &(e->lock);
  LOCK(lock);
  e->value = value;
  if (e->count == 0) {
    e->sum = value;
    e->count = 1;
    e->min = value;
    e->max = value;
  } else {
    e->sum += value;
    e->count++;
    e->min = MIN(e->min, value);
    e->max = MAX(e->max, value);
  }
  if (e->func) e->func(e);
  UNLOCK(lock);

  return 0;
}

// Initialize the location pointed to by 'id' to a new histogram profile entry
// associated with 'file' and 'line', or do nothing if already initialized.

int initHistProfile(void** id, char* file, int line, int nbins, ...) {
  DO_LOCK(&glock);
  entry_t e = (entry_t)*id;
  if (notInitialized) {
    atexit(dumpProfile);
    notInitialized = false;
  }

  if (e == nullptr) {
    e = findEntry(file, line);
    if (e) {
      *id = e;
    }
  }

  if (e == nullptr) {
    va_list va;
    hist_t h;
    int b, n, s;
    int64_t* lb;

    e = (entry_t)malloc(sizeof(entry));
    e->lock = LOCK_IS_FREE;
    e->file = file;
    e->line = line;
    e->value = 0;
    e->sum = 0;
    e->count = 0;
    e->min = 0;
    e->max = 0;
    e->func = nullptr;
    e->h = h = (hist_t)malloc(sizeof(hist));
    n = 1 + MAX(nbins, 0);
    h->nbins = n - 1;
    s = n * sizeof(int64_t);
    lb = (int64_t*)malloc(s);
    h->lb = lb;
    VMPI_memset(h->lb, 0, s);
    h->count = (int64_t*)malloc(s);
    VMPI_memset(h->count, 0, s);

    va_start(va, nbins);
    for (b = 0; b < nbins; b++) {
      // lb[b] = va_arg (va, int64_t);
      lb[b] = va_arg(va, int);
    }
    lb[b] = MAXINT64;
    va_end(va);

    e->genptr = nullptr;
    VMPI_memset(&e->ivar, 0, sizeof(e->ivar));
    VMPI_memset(&e->i64var, 0, sizeof(e->i64var));
    VMPI_memset(&e->dvar, 0, sizeof(e->dvar));
    e->next = entries;
    entries = e;
    *id = e;
  }
  DO_UNLOCK(&glock);

  return 0;
}

// Record a histogram profile event.

int histValue(void* id, int64_t value) {
  entry_t e = (entry_t)id;
  long* lock = &(e->lock);
  hist_t h = e->h;
  int nbins = h->nbins;
  int64_t* lb = h->lb;
  int b;

  LOCK(lock);
  e->value = value;
  if (e->count == 0) {
    e->sum = value;
    e->count = 1;
    e->min = value;
    e->max = value;
  } else {
    e->sum += value;
    e->count++;
    e->min = MIN(e->min, value);
    e->max = MAX(e->max, value);
  }
  for (b = 0; b < nbins; b++) {
    if (value < lb[b]) break;
  }
  h->count[b]++;
  UNLOCK(lock);

  return 0;
}

#if defined(_MSC_VER) && defined(_M_IX86)
uint64_t readTimestampCounter() {
  // read the cpu cycle counter.  1 tick = 1 cycle on IA32
  _asm rdtsc;
}
#elif defined(__GNUC__) && (__i386__ || __x86_64__)
uint64_t readTimestampCounter() {
  uint32_t lo, hi;
  __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));
  return (uint64_t(hi) << 32) | lo;
}
#else
// add stub for platforms without it, so fat builds don't fail
uint64_t readTimestampCounter() { return 0; }
#endif

quality84%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.