1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
namespace StatsViewer
{
/// <summary>
/// The stats table shared memory segment contains this
/// header structure.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
internal struct StatsFileHeader {
public int version;
public int size;
public int max_counters;
public int max_threads;
};
/// <summary>
/// An entry in the StatsTable.
/// </summary>
class StatsTableEntry {
public StatsTableEntry(int id, string name, StatsTable table) {
id_ = id;
name_ = name;
table_ = table;
}
/// <summary>
/// The unique id for this entry
/// </summary>
public int id { get { return id_; } }
/// <summary>
/// The name for this entry.
/// </summary>
public string name { get { return name_; } }
/// <summary>
/// The value of this entry now.
/// </summary>
public int GetValue(int filter_pid) {
return table_.GetValue(id_, filter_pid);
}
private int id_;
private string name_;
private StatsTable table_;
}
// An interface for StatsCounters
interface IStatsCounter {
// The name of the counter
string name { get; }
}
// A counter.
class StatsCounter : IStatsCounter {
public StatsCounter(StatsTableEntry entry) {
entry_ = entry;
}
public string name {
get {
return entry_.name;
}
}
public int GetValue(int filter_pid) {
return entry_.GetValue(filter_pid);
}
private StatsTableEntry entry_;
}
// A timer.
class StatsTimer : IStatsCounter {
public StatsTimer(StatsTableEntry entry)
{
entry_ = entry;
}
public string name {
get {
return entry_.name;
}
}
public int GetValue(int filter_pid) {
return entry_.GetValue(filter_pid);
}
private StatsTableEntry entry_;
}
// A rate.
class StatsCounterRate : IStatsCounter
{
public StatsCounterRate(StatsCounter counter, StatsTimer timer) {
counter_ = counter;
timer_ = timer;
}
public string name { get { return counter_.name; } }
public int GetCount(int filter_pid) {
return counter_.GetValue(filter_pid);
}
public int GetTime(int filter_pid) {
return timer_.GetValue(filter_pid);
}
private StatsCounter counter_;
private StatsTimer timer_;
}
/// <summary>
/// This is a C# reader for the chrome stats_table.
/// </summary>
class StatsTable {
internal const int kMaxThreadNameLength = 32;
internal const int kMaxCounterNameLength = 32;
/// <summary>
/// Open a StatsTable
/// </summary>
public StatsTable() {
}
#region Public Properties
/// <summary>
/// Get access to the counters in the table.
/// </summary>
public StatsTableCounters Counters() {
return new StatsTableCounters(this);
}
/// <summary>
/// Get access to the processes in the table
/// </summary>
public ICollection Processes {
get {
return new StatsTableProcesses(this);
}
}
#endregion
#region Internal Properties
//
// The internal methods are accessible to the enumerators
// and helper classes below.
//
/// <summary>
/// Access to the table header
/// </summary>
internal StatsFileHeader Header {
get { return header_; }
}
/// <summary>
/// Get the offset of the ThreadName table
/// </summary>
internal long ThreadNamesOffset {
get {
return memory_.ToInt64() + Marshal.SizeOf(typeof(StatsFileHeader));
}
}
/// <summary>
/// Get the offset of the PIDs table
/// </summary>
internal long PidsOffset {
get {
long offset = ThreadNamesOffset;
// Thread names table
offset += AlignedSize(header_.max_threads * kMaxThreadNameLength * 2);
// Thread TID table
offset += AlignedSize(header_.max_threads *
Marshal.SizeOf(typeof(int)));
return offset;
}
}
/// <summary>
/// Get the offset of the CounterName table
/// </summary>
internal long CounterNamesOffset {
get {
long offset = PidsOffset;
// Thread PID table
offset += AlignedSize(header_.max_threads *
Marshal.SizeOf(typeof(int)));
return offset;
}
}
/// <summary>
/// Get the offset of the Data table
/// </summary>
internal long DataOffset {
get {
long offset = CounterNamesOffset;
// Counter names table
offset += AlignedSize(header_.max_counters *
kMaxCounterNameLength * 2);
return offset;
}
}
#endregion
#region Public Methods
/// <summary>
/// Opens the memory map
/// </summary>
/// <returns></returns>
/// <param name="name">The name of the file to open</param>
public bool Open(string name) {
map_handle_ =
Win32.OpenFileMapping((int)Win32.MapAccess.FILE_MAP_WRITE, false,
name);
if (map_handle_ == IntPtr.Zero)
return false;
memory_ =
Win32.MapViewOfFile(map_handle_, (int)Win32.MapAccess.FILE_MAP_WRITE,
0,0, 0);
if (memory_ == IntPtr.Zero) {
Win32.CloseHandle(map_handle_);
return false;
}
header_ = (StatsFileHeader)Marshal.PtrToStructure(memory_, header_.GetType());
return true;
}
/// <summary>
/// Close the mapped file.
/// </summary>
public void Close() {
Win32.UnmapViewOfFile(memory_);
Win32.CloseHandle(map_handle_);
}
/// <summary>
/// Zero out the stats file.
/// </summary>
public void Zero() {
long offset = DataOffset;
for (int threads = 0; threads < header_.max_threads; threads++) {
for (int counters = 0; counters < header_.max_counters; counters++) {
Marshal.WriteInt32((IntPtr) offset, 0);
offset += Marshal.SizeOf(typeof(int));
}
}
}
/// <summary>
/// Get the value for a StatsCounterEntry now.
/// </summary>
/// <returns></returns>
/// <param name="filter_pid">If a specific PID is being queried, filter to this PID. 0 means use all data.</param>
/// <param name="id">The id of the CounterEntry to get the value for.</param>
public int GetValue(int id, int filter_pid) {
long pid_offset = PidsOffset;
long data_offset = DataOffset;
data_offset += id * (Header.max_threads *
Marshal.SizeOf(typeof(int)));
int rv = 0;
for (int cols = 0; cols < Header.max_threads; cols++)
{
int pid = Marshal.ReadInt32((IntPtr)pid_offset);
if (filter_pid == 0 || filter_pid == pid)
{
rv += Marshal.ReadInt32((IntPtr)data_offset);
}
data_offset += Marshal.SizeOf(typeof(int));
pid_offset += Marshal.SizeOf(typeof(int));
}
return rv;
}
#endregion
#region Private Methods
/// <summary>
/// Align to 4-byte boundaries
/// </summary>
/// <param name="size"></param>
/// <returns></returns>
private long AlignedSize(long size) {
Debug.Assert(sizeof(int) == 4);
return size + (sizeof(int) - (size % sizeof(int))) % sizeof(int);
}
#endregion
#region Private Members
private IntPtr memory_;
private IntPtr map_handle_;
private StatsFileHeader header_;
#endregion
}
/// <summary>
/// Enumerable list of Counters in the StatsTable
/// </summary>
class StatsTableCounters : ICollection {
/// <summary>
/// Create the list of counters
/// </summary>
/// <param name="table"></param>
/// pid</param>
public StatsTableCounters(StatsTable table) {
table_ = table;
counter_hi_water_mark_ = -1;
counters_ = new List<IStatsCounter>();
FindCounters();
}
/// <summary>
/// Scans the table for new entries.
/// </summary>
public void Update() {
FindCounters();
}
#region IEnumerable Members
public IEnumerator GetEnumerator() {
return counters_.GetEnumerator();
}
#endregion
#region ICollection Members
public void CopyTo(Array array, int index) {
throw new Exception("The method or operation is not implemented.");
}
public int Count {
get {
return counters_.Count;
}
}
public bool IsSynchronized {
get {
throw new Exception("The method or operation is not implemented.");
}
}
public object SyncRoot {
get {
throw new Exception("The method or operation is not implemented.");
}
}
#endregion
#region Private Methods
/// <summary>
/// Create a counter based on an entry
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
/// <returns></returns>
private IStatsCounter NameToCounter(int id, string name)
{
IStatsCounter rv = null;
// check if the name has a type encoded
if (name.Length > 2 && name[1] == ':')
{
StatsTableEntry entry = new StatsTableEntry(id, name.Substring(2), table_);
switch (name[0])
{
case 't':
rv = new StatsTimer(entry);
break;
case 'c':
rv = new StatsCounter(entry);
break;
}
}
else
{
StatsTableEntry entry = new StatsTableEntry(id, name, table_);
rv = new StatsCounter(entry);
}
return rv;
}
// If we have two StatsTableEntries with the same name,
// attempt to upgrade them to a higher level type.
// Example: A counter + a timer == a rate!
private void UpgradeCounter(IStatsCounter old_counter, IStatsCounter counter)
{
if (old_counter is StatsCounter && counter is StatsTimer)
{
StatsCounterRate rate = new StatsCounterRate(old_counter as StatsCounter,
counter as StatsTimer);
counters_.Remove(old_counter);
counters_.Add(rate);
}
else if (old_counter is StatsTimer && counter is StatsCounter)
{
StatsCounterRate rate = new StatsCounterRate(counter as StatsCounter,
old_counter as StatsTimer);
counters_.Remove(old_counter);
counters_.Add(rate);
}
}
/// <summary>
/// Find the counters in the table and insert into the counters_
/// hash table.
/// </summary>
private void FindCounters()
{
Debug.Assert(table_.Header.max_counters > 0);
int index = counter_hi_water_mark_;
do
{
// Find an entry in the table.
index++;
long offset = table_.CounterNamesOffset +
(index * StatsTable.kMaxCounterNameLength * 2);
string name = Marshal.PtrToStringUni((IntPtr)offset);
if (name.Length == 0)
continue;
// Record that we've already looked at this StatsTableEntry.
counter_hi_water_mark_ = index;
IStatsCounter counter = NameToCounter(index, name);
if (counter != null)
{
IStatsCounter old_counter = FindExistingCounter(counter.name);
if (old_counter != null)
UpgradeCounter(old_counter, counter);
else
counters_.Add(counter);
}
} while (index < table_.Header.max_counters - 1);
}
/// <summary>
/// Find an existing counter in our table
/// </summary>
/// <param name="name"></param>
private IStatsCounter FindExistingCounter(string name) {
foreach (IStatsCounter ctr in counters_)
{
if (ctr.name == name)
return ctr;
}
return null;
}
#endregion
#region Private Members
private StatsTable table_;
private List<IStatsCounter> counters_;
// Highest index of counters processed.
private int counter_hi_water_mark_;
#endregion
}
/// <summary>
/// A collection of processes
/// </summary>
class StatsTableProcesses : ICollection
{
/// <summary>
/// Constructor
/// </summary>
/// <param name="table"></param>
public StatsTableProcesses(StatsTable table) {
table_ = table;
pids_ = new List<int>();
Initialize();
}
#region ICollection Members
public void CopyTo(Array array, int index) {
throw new Exception("The method or operation is not implemented.");
}
public int Count {
get {
return pids_.Count;
}
}
public bool IsSynchronized {
get {
throw new Exception("The method or operation is not implemented.");
}
}
public object SyncRoot {
get {
throw new Exception("The method or operation is not implemented.");
}
}
#endregion
#region IEnumerable Members
public IEnumerator GetEnumerator() {
return pids_.GetEnumerator();
}
#endregion
/// <summary>
/// Initialize the pid list.
/// </summary>
private void Initialize() {
long offset = table_.ThreadNamesOffset;
for (int index = 0; index < table_.Header.max_threads; index++) {
string thread_name = Marshal.PtrToStringUni((IntPtr)offset);
if (thread_name.Length > 0) {
long pidOffset = table_.PidsOffset + index *
Marshal.SizeOf(typeof(int));
int pid = Marshal.ReadInt32((IntPtr)pidOffset);
if (!pids_.Contains(pid))
pids_.Add(pid);
}
offset += StatsTable.kMaxThreadNameLength * 2;
}
}
#region Private Members
private StatsTable table_;
private List<int> pids_;
#endregion
}
}
|