third_party/tcmalloc/chromium/src/profiledata.cc - mirrors/engine - Git at Google

 // Copyright (c) 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // ---
 // Author: Sanjay Ghemawat
 //         Chris Demetriou (refactoring)
 //
 // Collect profiling data.

 #include <config.h>
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <sys/time.h>
 #include <string.h>
 #include <fcntl.h>

 #include "profiledata.h"

 #include "base/logging.h"
 #include "base/sysinfo.h"

 // All of these are initialized in profiledata.h.
 const int ProfileData::kMaxStackDepth;
 const int ProfileData::kAssociativity;
 const int ProfileData::kBuckets;
 const int ProfileData::kBufferLength;

 ProfileData::Options::Options()
     : frequency_(1) {
 }

 // This function is safe to call from asynchronous signals (but is not
 // re-entrant).  However, that's not part of its public interface.
 void ProfileData::Evict(const Entry& entry) {
   const int d = entry.depth;
   const int nslots = d + 2;     // Number of slots needed in eviction buffer
   if (num_evicted_ + nslots > kBufferLength) {
     FlushEvicted();
     assert(num_evicted_ == 0);
     assert(nslots <= kBufferLength);
   }
   evict_[num_evicted_++] = entry.count;
   evict_[num_evicted_++] = d;
   memcpy(&evict_[num_evicted_], entry.stack, d * sizeof(Slot));
   num_evicted_ += d;
 }

 ProfileData::ProfileData()
     : hash_(0),
       evict_(0),
       num_evicted_(0),
       out_(-1),
       count_(0),
       evictions_(0),
       total_bytes_(0),
       fname_(0),
       start_time_(0) {
 }

 bool ProfileData::Start(const char* fname,
                         const ProfileData::Options& options) {
   if (enabled()) {
     return false;
   }

   // Open output file and initialize various data structures
   int fd = open(fname, O_CREAT | O_WRONLY | O_TRUNC, 0666);
   if (fd < 0) {
     // Can't open outfile for write
     return false;
   }

   start_time_ = time(NULL);
   fname_ = strdup(fname);

   // Reset counters
   num_evicted_ = 0;
   count_       = 0;
   evictions_   = 0;
   total_bytes_ = 0;

   hash_ = new Bucket[kBuckets];
   evict_ = new Slot[kBufferLength];
   memset(hash_, 0, sizeof(hash_[0]) * kBuckets);

   // Record special entries
   evict_[num_evicted_++] = 0;                     // count for header
   evict_[num_evicted_++] = 3;                     // depth for header
   evict_[num_evicted_++] = 0;                     // Version number
   CHECK_NE(0, options.frequency());
   int period = 1000000 / options.frequency();
   evict_[num_evicted_++] = period;                // Period (microseconds)
   evict_[num_evicted_++] = 0;                     // Padding

   out_ = fd;

   return true;
 }

 ProfileData::~ProfileData() {
   Stop();
 }

 // Dump /proc/maps data to fd.  Copied from heap-profile-table.cc.
 #define NO_INTR(fn)  do {} while ((fn) < 0 && errno == EINTR)

 static void FDWrite(int fd, const char* buf, size_t len) {
   while (len > 0) {
     ssize_t r;
     NO_INTR(r = write(fd, buf, len));
     RAW_CHECK(r >= 0, "write failed");
     buf += r;
     len -= r;
   }
 }

 static void DumpProcSelfMaps(int fd) {
   ProcMapsIterator::Buffer iterbuf;
   ProcMapsIterator it(0, &iterbuf);   // 0 means "current pid"

   uint64 start, end, offset;
   int64 inode;
   char *flags, *filename;
   ProcMapsIterator::Buffer linebuf;
   while (it.Next(&start, &end, &flags, &offset, &inode, &filename)) {
     int written = it.FormatLine(linebuf.buf_, sizeof(linebuf.buf_),
                                 start, end, flags, offset, inode, filename,
                                 0);
     FDWrite(fd, linebuf.buf_, written);
   }
 }

 void ProfileData::Stop() {
   if (!enabled()) {
     return;
   }

   // Move data from hash table to eviction buffer
   for (int b = 0; b < kBuckets; b++) {
     Bucket* bucket = &hash_[b];
     for (int a = 0; a < kAssociativity; a++) {
       if (bucket->entry[a].count > 0) {
         Evict(bucket->entry[a]);
       }
     }
   }

   if (num_evicted_ + 3 > kBufferLength) {
     // Ensure there is enough room for end of data marker
     FlushEvicted();
   }

   // Write end of data marker
   evict_[num_evicted_++] = 0;         // count
   evict_[num_evicted_++] = 1;         // depth
   evict_[num_evicted_++] = 0;         // end of data marker
   FlushEvicted();

   // Dump "/proc/self/maps" so we get list of mapped shared libraries
   DumpProcSelfMaps(out_);

   Reset();
   fprintf(stderr, "PROFILE: interrupts/evictions/bytes = %d/%d/%" PRIuS "\n",
           count_, evictions_, total_bytes_);
 }

 void ProfileData::Reset() {
   if (!enabled()) {
     return;
   }

   // Don't reset count_, evictions_, or total_bytes_ here.  They're used
   // by Stop to print information about the profile after reset, and are
   // cleared by Start when starting a new profile.
   close(out_);
   delete[] hash_;
   hash_ = 0;
   delete[] evict_;
   evict_ = 0;
   num_evicted_ = 0;
   free(fname_);
   fname_ = 0;
   start_time_ = 0;

   out_ = -1;
 }

 // This function is safe to call from asynchronous signals (but is not
 // re-entrant).  However, that's not part of its public interface.
 void ProfileData::GetCurrentState(State* state) const {
   if (enabled()) {
     state->enabled = true;
     state->start_time = start_time_;
     state->samples_gathered = count_;
     int buf_size = sizeof(state->profile_name);
     strncpy(state->profile_name, fname_, buf_size);
     state->profile_name[buf_size-1] = '\0';
   } else {
     state->enabled = false;
     state->start_time = 0;
     state->samples_gathered = 0;
     state->profile_name[0] = '\0';
   }
 }

 // This function is safe to call from asynchronous signals (but is not
 // re-entrant).  However, that's not part of its public interface.
 void ProfileData::FlushTable() {
   if (!enabled()) {
     return;
   }

   // Move data from hash table to eviction buffer
   for (int b = 0; b < kBuckets; b++) {
     Bucket* bucket = &hash_[b];
     for (int a = 0; a < kAssociativity; a++) {
       if (bucket->entry[a].count > 0) {
         Evict(bucket->entry[a]);
         bucket->entry[a].depth = 0;
         bucket->entry[a].count = 0;
       }
     }
   }

   // Write out all pending data
   FlushEvicted();
 }

 void ProfileData::Add(int depth, const void* const* stack) {
   if (!enabled()) {
     return;
   }

   if (depth > kMaxStackDepth) depth = kMaxStackDepth;
   RAW_CHECK(depth > 0, "ProfileData::Add depth <= 0");

   // Make hash-value
   Slot h = 0;
   for (int i = 0; i < depth; i++) {
     Slot slot = reinterpret_cast<Slot>(stack[i]);
     h = (h << 8) | (h >> (8*(sizeof(h)-1)));
     h += (slot * 31) + (slot * 7) + (slot * 3);
   }

   count_++;

   // See if table already has an entry for this trace
   bool done = false;
   Bucket* bucket = &hash_[h % kBuckets];
   for (int a = 0; a < kAssociativity; a++) {
     Entry* e = &bucket->entry[a];
     if (e->depth == depth) {
       bool match = true;
       for (int i = 0; i < depth; i++) {
         if (e->stack[i] != reinterpret_cast<Slot>(stack[i])) {
           match = false;
           break;
         }
       }
       if (match) {
         e->count++;
         done = true;
         break;
       }
     }
   }

   if (!done) {
     // Evict entry with smallest count
     Entry* e = &bucket->entry[0];
     for (int a = 1; a < kAssociativity; a++) {
       if (bucket->entry[a].count < e->count) {
         e = &bucket->entry[a];
       }
     }
     if (e->count > 0) {
       evictions_++;
       Evict(*e);
     }

     // Use the newly evicted entry
     e->depth = depth;
     e->count = 1;
     for (int i = 0; i < depth; i++) {
       e->stack[i] = reinterpret_cast<Slot>(stack[i]);
     }
   }
 }

 // This function is safe to call from asynchronous signals (but is not
 // re-entrant).  However, that's not part of its public interface.
 void ProfileData::FlushEvicted() {
   if (num_evicted_ > 0) {
     const char* buf = reinterpret_cast<char*>(evict_);
     size_t bytes = sizeof(evict_[0]) * num_evicted_;
     total_bytes_ += bytes;
     FDWrite(out_, buf, bytes);
   }
   num_evicted_ = 0;
 }
	// Copyright (c) 2007, Google Inc.
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	//
	// ---
	// Author: Sanjay Ghemawat
	// Chris Demetriou (refactoring)
	//
	// Collect profiling data.

	#include <config.h>
	#include <assert.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <errno.h>
	#ifdef HAVE_UNISTD_H
	#include <unistd.h>
	#endif
	#include <sys/time.h>
	#include <string.h>
	#include <fcntl.h>

	#include "profiledata.h"

	#include "base/logging.h"
	#include "base/sysinfo.h"

	// All of these are initialized in profiledata.h.
	const int ProfileData::kMaxStackDepth;
	const int ProfileData::kAssociativity;
	const int ProfileData::kBuckets;
	const int ProfileData::kBufferLength;

	ProfileData::Options::Options()
	: frequency_(1) {
	}

	// This function is safe to call from asynchronous signals (but is not
	// re-entrant). However, that's not part of its public interface.
	void ProfileData::Evict(const Entry& entry) {
	const int d = entry.depth;
	const int nslots = d + 2; // Number of slots needed in eviction buffer
	if (num_evicted_ + nslots > kBufferLength) {
	FlushEvicted();
	assert(num_evicted_ == 0);
	assert(nslots <= kBufferLength);
	}
	evict_[num_evicted_++] = entry.count;
	evict_[num_evicted_++] = d;
	memcpy(&evict_[num_evicted_], entry.stack, d * sizeof(Slot));
	num_evicted_ += d;
	}

	ProfileData::ProfileData()
	: hash_(0),
	evict_(0),
	num_evicted_(0),
	out_(-1),
	count_(0),
	evictions_(0),
	total_bytes_(0),
	fname_(0),
	start_time_(0) {
	}

	bool ProfileData::Start(const char* fname,
	const ProfileData::Options& options) {
	if (enabled()) {
	return false;
	}

	// Open output file and initialize various data structures
	int fd = open(fname, O_CREAT \| O_WRONLY \| O_TRUNC, 0666);
	if (fd < 0) {
	// Can't open outfile for write
	return false;
	}

	start_time_ = time(NULL);
	fname_ = strdup(fname);

	// Reset counters
	num_evicted_ = 0;
	count_ = 0;
	evictions_ = 0;
	total_bytes_ = 0;

	hash_ = new Bucket[kBuckets];
	evict_ = new Slot[kBufferLength];
	memset(hash_, 0, sizeof(hash_[0]) * kBuckets);

	// Record special entries
	evict_[num_evicted_++] = 0; // count for header
	evict_[num_evicted_++] = 3; // depth for header
	evict_[num_evicted_++] = 0; // Version number
	CHECK_NE(0, options.frequency());
	int period = 1000000 / options.frequency();
	evict_[num_evicted_++] = period; // Period (microseconds)
	evict_[num_evicted_++] = 0; // Padding

	out_ = fd;

	return true;
	}

	ProfileData::~ProfileData() {
	Stop();
	}

	// Dump /proc/maps data to fd. Copied from heap-profile-table.cc.
	#define NO_INTR(fn) do {} while ((fn) < 0 && errno == EINTR)

	static void FDWrite(int fd, const char* buf, size_t len) {
	while (len > 0) {
	ssize_t r;
	NO_INTR(r = write(fd, buf, len));
	RAW_CHECK(r >= 0, "write failed");
	buf += r;
	len -= r;
	}
	}

	static void DumpProcSelfMaps(int fd) {
	ProcMapsIterator::Buffer iterbuf;
	ProcMapsIterator it(0, &iterbuf); // 0 means "current pid"

	uint64 start, end, offset;
	int64 inode;
	char flags, filename;
	ProcMapsIterator::Buffer linebuf;
	while (it.Next(&start, &end, &flags, &offset, &inode, &filename)) {
	int written = it.FormatLine(linebuf.buf_, sizeof(linebuf.buf_),
	start, end, flags, offset, inode, filename,
	0);
	FDWrite(fd, linebuf.buf_, written);
	}
	}

	void ProfileData::Stop() {
	if (!enabled()) {
	return;
	}

	// Move data from hash table to eviction buffer
	for (int b = 0; b < kBuckets; b++) {
	Bucket* bucket = &hash_[b];
	for (int a = 0; a < kAssociativity; a++) {
	if (bucket->entry[a].count > 0) {
	Evict(bucket->entry[a]);
	}
	}
	}

	if (num_evicted_ + 3 > kBufferLength) {
	// Ensure there is enough room for end of data marker
	FlushEvicted();
	}

	// Write end of data marker
	evict_[num_evicted_++] = 0; // count
	evict_[num_evicted_++] = 1; // depth
	evict_[num_evicted_++] = 0; // end of data marker
	FlushEvicted();

	// Dump "/proc/self/maps" so we get list of mapped shared libraries
	DumpProcSelfMaps(out_);

	Reset();
	fprintf(stderr, "PROFILE: interrupts/evictions/bytes = %d/%d/%" PRIuS "\n",
	count_, evictions_, total_bytes_);
	}

	void ProfileData::Reset() {
	if (!enabled()) {
	return;
	}

	// Don't reset count_, evictions_, or total_bytes_ here. They're used
	// by Stop to print information about the profile after reset, and are
	// cleared by Start when starting a new profile.
	close(out_);
	delete[] hash_;
	hash_ = 0;
	delete[] evict_;
	evict_ = 0;
	num_evicted_ = 0;
	free(fname_);
	fname_ = 0;
	start_time_ = 0;

	out_ = -1;
	}

	// This function is safe to call from asynchronous signals (but is not
	// re-entrant). However, that's not part of its public interface.
	void ProfileData::GetCurrentState(State* state) const {
	if (enabled()) {
	state->enabled = true;
	state->start_time = start_time_;
	state->samples_gathered = count_;
	int buf_size = sizeof(state->profile_name);
	strncpy(state->profile_name, fname_, buf_size);
	state->profile_name[buf_size-1] = '\0';
	} else {
	state->enabled = false;
	state->start_time = 0;
	state->samples_gathered = 0;
	state->profile_name[0] = '\0';
	}
	}

	// This function is safe to call from asynchronous signals (but is not
	// re-entrant). However, that's not part of its public interface.
	void ProfileData::FlushTable() {
	if (!enabled()) {
	return;
	}

	// Move data from hash table to eviction buffer
	for (int b = 0; b < kBuckets; b++) {
	Bucket* bucket = &hash_[b];
	for (int a = 0; a < kAssociativity; a++) {
	if (bucket->entry[a].count > 0) {
	Evict(bucket->entry[a]);
	bucket->entry[a].depth = 0;
	bucket->entry[a].count = 0;
	}
	}
	}

	// Write out all pending data
	FlushEvicted();
	}

	void ProfileData::Add(int depth, const void* const* stack) {
	if (!enabled()) {
	return;
	}

	if (depth > kMaxStackDepth) depth = kMaxStackDepth;
	RAW_CHECK(depth > 0, "ProfileData::Add depth <= 0");

	// Make hash-value
	Slot h = 0;
	for (int i = 0; i < depth; i++) {
	Slot slot = reinterpret_cast<Slot>(stack[i]);
	h = (h << 8) \| (h >> (8*(sizeof(h)-1)));
	h += (slot * 31) + (slot * 7) + (slot * 3);
	}

	count_++;

	// See if table already has an entry for this trace
	bool done = false;
	Bucket* bucket = &hash_[h % kBuckets];
	for (int a = 0; a < kAssociativity; a++) {
	Entry* e = &bucket->entry[a];
	if (e->depth == depth) {
	bool match = true;
	for (int i = 0; i < depth; i++) {
	if (e->stack[i] != reinterpret_cast<Slot>(stack[i])) {
	match = false;
	break;
	}
	}
	if (match) {
	e->count++;
	done = true;
	break;
	}
	}
	}

	if (!done) {
	// Evict entry with smallest count
	Entry* e = &bucket->entry[0];
	for (int a = 1; a < kAssociativity; a++) {
	if (bucket->entry[a].count < e->count) {
	e = &bucket->entry[a];
	}
	}
	if (e->count > 0) {
	evictions_++;
	Evict(*e);
	}

	// Use the newly evicted entry
	e->depth = depth;
	e->count = 1;
	for (int i = 0; i < depth; i++) {
	e->stack[i] = reinterpret_cast<Slot>(stack[i]);
	}
	}
	}

	// This function is safe to call from asynchronous signals (but is not
	// re-entrant). However, that's not part of its public interface.
	void ProfileData::FlushEvicted() {
	if (num_evicted_ > 0) {
	const char* buf = reinterpret_cast<char*>(evict_);
	size_t bytes = sizeof(evict_[0]) * num_evicted_;
	total_bytes_ += bytes;
	FDWrite(out_, buf, bytes);
	}
	num_evicted_ = 0;
	}