Files
mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/ThreadTrace.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

297 lines
9.1 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel
{
using System;
using System.IO;
using System.Threading;
using System.Security;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
// Enable this code to track which thread operations occur on
#if false
static class ThreadTrace
{
static LocalDataStoreSlot slot;
static List<ThreadLog> logs;
static string logFileName;
static bool isEnabled;
static long frequency;
static ThreadTrace()
{
logFileName = Environment.GetEnvironmentVariable("ThreadTrace");
if (logFileName == null)
logFileName = "";
isEnabled = logFileName.Length > 0;
if (isEnabled)
{
slot = Thread.AllocateDataSlot();
logs = new List<ThreadLog>();
NativeMethods.QueryPerformanceFrequency(out frequency);
Console.WriteLine("ThreadTrace: enabled");
new Thread(ThreadProc).Start();
}
}
static bool stopTracing;
public static void StopTracing()
{
stopTracing = true;
}
static void ThreadProc()
{
while (!stopTracing)
{
Thread.Sleep(20000);
WriteLogFile();
Console.WriteLine("ThreadTrace: " + logFileName + " saved.");
}
}
static object ThisLock
{
get { return logs; }
}
public static void Trace(string operation)
{
if (isEnabled)
{
TraceInternal(operation);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
static void TraceInternal(string operation)
{
long time;
NativeMethods.QueryPerformanceCounter(out time);
ThreadLog log = (ThreadLog)Thread.GetData(slot);
if (log == null)
{
Thread currentThread = Thread.CurrentThread;
log = new ThreadLog(currentThread);
lock (ThisLock)
{
logs.Add(log);
}
Thread.SetData(slot, log);
}
log.Append(time, operation);
}
static void WriteLogFile()
{
Trace("ThreadTrace.Save");
TextWriter writer = File.CreateText(logFileName);
using (writer)
{
ThreadLogSnapshot[] logSnapshots = new ThreadLogSnapshot[logs.Count];
writer.Write("Time");
for (int i = 0; i < logs.Count; i++)
{
logSnapshots[i] = logs[i].GetSnapshot();
writer.Write(", Thread ");
writer.Write(i.ToString());
}
writer.WriteLine();
writer.Write("(Ms)");
foreach (ThreadLog log in logs)
{
if (log.IsThreadPoolThread)
writer.Write(", (ThreadPool)");
else if (log.IsBackgroundThread)
writer.Write(", (Background)");
else
writer.Write(", (Main)");
}
writer.WriteLine();
int[] indices = new int[logs.Count];
int count = 0;
for (int i = 0; i < logs.Count; i++)
count += logSnapshots[i].Count;
for (int j = 0; j < count; j++)
{
int earliestIndex = -1;
long earliestTime = long.MaxValue;
for (int i = 0; i < logs.Count; i++)
{
ThreadLogSnapshot logSnapshot = logSnapshots[i];
int index = indices[i];
if (index >= logSnapshot.Count)
continue;
long time = logSnapshot[index].time;
if (time < earliestTime)
{
earliestIndex = i;
earliestTime = time;
}
}
ThreadLogEntry entry = logSnapshots[earliestIndex][indices[earliestIndex]];
double timeInMilliseconds = (entry.time * 1000) / (double)frequency;
writer.Write(timeInMilliseconds);
for (int i = 0; i < logs.Count; i++)
{
writer.Write(", ");
if (i == earliestIndex)
{
writer.Write('\"');
writer.Write(entry.operation);
writer.Write('\"');
}
}
writer.WriteLine();
indices[earliestIndex]++;
}
}
}
struct ThreadLogEntry
{
public long time;
public string operation;
public ThreadLogEntry(long time, string operation)
{
this.time = time;
this.operation = operation;
}
}
class ThreadLogSnapshot
{
ThreadLogEntry[] entries;
public ThreadLogSnapshot(ThreadLogEntry[] entries)
{
this.entries = entries;
}
public int Count
{
get
{
return this.entries.Length;
}
}
public ThreadLogEntry this[int index]
{
get
{
return this.entries[index];
}
}
}
class ThreadLog
{
int count;
ThreadLogEntry[] buffer;
const int bufferSize = 5000;
const int maxBuffers = 4096;
bool isThreadPoolThread;
bool isBackgroundThread;
ThreadLogEntry[][] buffers;
int bufferCount;
public ThreadLog(Thread thread)
{
this.isThreadPoolThread = thread.IsThreadPoolThread;
this.isBackgroundThread = thread.IsBackground;
this.buffer = new ThreadLogEntry[bufferSize];
this.buffers = new ThreadLogEntry[maxBuffers][];
}
object ThisLock
{
get { return this; }
}
public bool IsThreadPoolThread
{
get { return this.isThreadPoolThread; }
}
public bool IsBackgroundThread
{
get { return this.isBackgroundThread; }
}
public void Append(long time, string operation)
{
if (this.count == bufferSize)
{
lock (ThisLock)
{
this.buffers[bufferCount++] = this.buffer;
this.buffer = new ThreadLogEntry[bufferSize];
this.count = 0;
}
}
this.buffer[this.count++] = new ThreadLogEntry(time, operation);
}
public ThreadLogSnapshot GetSnapshot()
{
int currentBufferCount;
int currentCount;
ThreadLogEntry[] currentBuffer;
lock (ThisLock)
{
currentBufferCount = this.bufferCount;
currentCount = this.count;
currentBuffer = this.buffer;
}
ThreadLogEntry[] entries = new ThreadLogEntry[currentBufferCount * bufferSize + currentCount];
int index = 0;
for (int i = 0; i < currentBufferCount; i++)
{
Array.Copy(buffers[i], 0, entries, index, bufferSize);
index += bufferSize;
}
Array.Copy(currentBuffer, 0, entries, index, currentCount);
return new ThreadLogSnapshot(entries);
}
}
[SuppressUnmanagedCodeSecurity]
static class NativeMethods
{
[DllImport("kernel32.dll")]
[ResourceExposure(ResourceScope.None)]
public static extern int QueryPerformanceCounter(out long time);
[DllImport("kernel32.dll")]
[ResourceExposure(ResourceScope.None)]
public static extern int QueryPerformanceFrequency(out long frequency);
}
}
#else
static class ThreadTrace
{
public static void Trace(string operation)
{
}
public static void StopTracing()
{
}
public static void Save()
{
}
}
#endif
}