The Tor Browser: js/src/devtools/vprof/vprof.cpp@129ffea94266 (annotated)

js/src/devtools/vprof/vprof.cpp@129ffea94266 (annotated)

js/src/devtools/vprof/vprof.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; c-basic-offset: 4; 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 "windows.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

The Tor Browser / annotate

js/src/devtools/vprof/vprof.cpp@129ffea94266 (annotated)

js/src/devtools/vprof/vprof.cpp