internal unsafe static void Initialize(GCType gcType)
{
traceablePtrs = new ManagedPtrAccounting();
traceablePinnedPtrs = new ManagedPtrAccounting();
staticPtrs = new StaticPtrAccounting();
assertRTypeHeaders = new AssertRTypeHeaders();
forGCAssertRTypeHeaders = assertRTypeHeaders;
runtimeTypeReckoner = new RuntimeTypeReckoner();
forGCRuntimeTypeReckoner = runtimeTypeReckoner;
runtimeTypeMapper = new RuntimeTypeMapper();
forGCRuntimeTypeMapper = runtimeTypeMapper;
instanceReckoner = new InstanceReckoner();
forGCInstanceReckoner = instanceReckoner;
switch (gcType)
{
case GCType.MarkSweepCollector: {
forGCAssertRTypeHeaders = new SegregatedFreeList.ObjectVisitorWrapper(assertRTypeHeaders);
forGCRuntimeTypeReckoner = new SegregatedFreeList.ObjectVisitorWrapper(runtimeTypeReckoner);
forGCRuntimeTypeMapper = new SegregatedFreeList.ObjectVisitorWrapper(runtimeTypeMapper);
forGCInstanceReckoner = new SegregatedFreeList.ObjectVisitorWrapper(instanceReckoner);
break;
}
}
table = new RuntimeTypeAccounting[TABLE_SIZE];
MemoryAccounting.initialized = true;
}
public override void OnSCDestroy()
{
base.OnSCDestroy();
GCData = null;
GCType = GCType.Null;
GCName = "";
tpPosition = Vector2.zero;
}
public GCWorker()
{
GCThread = null;
GCWorking = false;
GCWorker._GCRequested = false;
GCWorker._GCGen = -1;
GCWorker._GCType = GCType.GCOptimized;
}
public static Transform KSTransform(GCType type = GCType.Right)
{
if (KSRight && type == GCType.Right)
{
return(KSRight.inputDeviceKSPartUI.ModelGC.transform);
}
else if (KSLeft && type == GCType.Left)
{
return(KSLeft.inputDeviceKSPartUI.ModelGC.transform);
}
return(null);
}
///API-No.153
/// <summary>
/// BTRight/BTLeft的四元数，全局坐标
/// </summary>
/// <param name="type">右手柄 BTRight / 左手柄 BTLeft</param>
/// <returns></returns>
public static Quaternion KSRotation(GCType type = GCType.Right)
{
if (KSRight && type == GCType.Right)
{
return(KSRight.inputDataKS.rotation);
}
else if (KSLeft && type == GCType.Left)
{
return(KSLeft.inputDataKS.rotation);
}
return(Quaternion.identity);
}
///API-No.154
/// <summary>
/// BTRight/BTLeft的位置信息，全局坐标
/// </summary>
/// <param name="type">右手柄 BTRight / 左手柄 BTLeft</param>
/// <returns></returns>
public static Vector3 KSPosition(GCType type = GCType.Right)
{
if (KSRight && type == GCType.Right)
{
return(KSRight.inputDataKS.position);
}
else if (KSLeft && type == GCType.Left)
{
return(KSLeft.inputDataKS.position);
}
return(Vector3.zero);
}
private void Collect(int gen = -1, GCType type = GCType.GCOptimized)
{
if (gen == -1)
{
gen = GC.MaxGeneration;
}
// GC 가 Request 되었다면 예외적으로 수행
if (!KanColleSettings.UseMemoryOptimize && !GCWorker._GCRequested)
{
return;
}
GCWorker._GCRequested = false;
GC.Collect(gen, type == GCType.GCOptimized ? GCCollectionMode.Optimized : GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
}
}
/// <summary>
/// Filter events according to checkboxes
/// </summary>
IEnumerable <GcEventWrapper> FilterEvent()
{
bool no_g0 = m_g0.UnChecked();
bool no_g1 = m_g1.UnChecked();
bool no_g2Blk = m_g2Blocking.UnChecked();
bool no_g2Bak = m_g2Background.UnChecked();
bool no_inducedBlocking = m_inducedBlocking.UnChecked();
bool no_inducedNonBlock = m_inducedNonblocking.UnChecked();
bool no_lowMemory = m_lowMemory.UnChecked();
bool no_allocSOH = m_allocSOH.UnChecked();
bool no_allocLOH = m_AllocLOH.UnChecked();
foreach (GcEventWrapper er in m_gcEvents)
{
TraceGC e = er.Event;
GCType typ = e.Type;
switch (e.Generation)
{
case 0:
if (no_g0)
{
continue;
}
break;
case 1:
if (no_g1)
{
continue;
}
break;
case 2:
if (no_g2Blk && (typ == GCType.NonConcurrentGC))
{
continue;
}
if (no_g2Bak && (typ == GCType.BackgroundGC))
{
continue;
}
break;
}
switch (e.Reason)
{
case GCReason.OutOfSpaceSOH:
case GCReason.AllocSmall:
if (no_allocSOH)
{
continue;
}
break;
case GCReason.InducedNotForced:
case GCReason.Induced:
if (no_inducedBlocking && (typ == GCType.NonConcurrentGC))
{
continue;
}
if (no_inducedNonBlock && (typ == GCType.BackgroundGC))
{
continue;
}
break;
case GCReason.OutOfSpaceLOH:
case GCReason.AllocLarge:
if (no_allocLOH)
{
continue;
}
break;
case GCReason.LowMemory:
case GCReason.InducedLowMemory:
if (no_lowMemory)
{
continue;
}
break;
case GCReason.Empty:
case GCReason.Internal:
default:
break;
}
yield return(er);
}
}
internal unsafe static void Report(GCType gcType)
{
if (!MemoryAccounting.initialized)
{
VTable.DebugPrint("MemoryAccounting invoked before"
+ " initialization was completed!\n");
return;
}
VTable.DebugPrint("\nCollector: ");
switch (gcType)
{
case GCType.AdaptiveCopyingCollector: {
VTable.DebugPrint("Adaptive Copying\n");
break;
}
case GCType.MarkSweepCollector: {
VTable.DebugPrint("Mark-Sweep\n");
break;
}
case GCType.SemispaceCollector: {
VTable.DebugPrint("Semispace\n");
break;
}
case GCType.SlidingCollector: {
VTable.DebugPrint("Sliding\n");
break;
}
case GCType.ConcurrentMSCollector: {
VTable.DebugPrint("Concurrent Mark-Sweep\n");
break;
}
case GCType.ReferenceCountingCollector: {
VTable.DebugPrint("Reference Counting\n");
VTable.NotImplemented();
return; // Not supported yet.
}
#if !SINGULARITY
case GCType.DeferredReferenceCountingCollector: {
VTable.DebugPrint("Deferred Reference Counting\n");
VTable.NotImplemented();
return; // Not supported yet.
}
#endif
default: {
VTable.NotReached("Unknown GC type: " + gcType);
break;
}
}
uint pageSize = (uint)(PageTable.PageSize >> 10);
VTable.DebugPrint("\nPage size: {0}KB\nVM size: {1} KB\n",
__arglist(pageSize,
pageSize * (uint)PageTable.pageTableCount));
ReportNonGCDetails();
ReportStackDetails();
ReportHeapDetails();
}
private static void TestMARSSessionPooling(string caseName, string connectionString, CommandType commandType,
ExecuteType executeType, ReaderTestType readerTestType, GCType gcType)
{
SqlCommand[] cmd = new SqlCommand[CONCURRENT_COMMANDS];
SqlDataReader[] gch = new SqlDataReader[CONCURRENT_COMMANDS];
using (SqlConnection con = new SqlConnection(connectionString))
{
con.Open();
for (int i = 0; i < CONCURRENT_COMMANDS; i++)
{
// Prepare all commands
cmd[i] = con.CreateCommand();
switch (commandType)
{
case CommandType.Text:
cmd[i].CommandText = _COMMAND_SQL;
cmd[i].CommandTimeout = 120;
break;
case CommandType.StoredProcedure:
cmd[i].CommandText = _COMMAND_RPC;
cmd[i].CommandTimeout = 120;
cmd[i].CommandType = CommandType.StoredProcedure;
break;
}
}
for (int i = 0; i < CONCURRENT_COMMANDS; i++)
{
switch (executeType)
{
case ExecuteType.ExecuteScalar:
cmd[i].ExecuteScalar();
break;
case ExecuteType.ExecuteNonQuery:
cmd[i].ExecuteNonQuery();
break;
case ExecuteType.ExecuteReader:
if (readerTestType != ReaderTestType.ReaderGC)
gch[i] = cmd[i].ExecuteReader();
switch (readerTestType)
{
case ReaderTestType.ReaderClose:
{
gch[i].Dispose();
break;
}
case ReaderTestType.ReaderDispose:
gch[i].Dispose();
break;
case ReaderTestType.ReaderGC:
gch[i] = null;
WeakReference weak = OpenReaderThenNullify(cmd[i]);
GC.Collect();
if (gcType == GCType.Wait)
{
GC.WaitForPendingFinalizers();
Assert.False(weak.IsAlive, "Error - target still alive!");
}
break;
case ReaderTestType.ConnectionClose:
GC.SuppressFinalize(gch[i]);
con.Close();
con.Open();
break;
case ReaderTestType.NoCloses:
GC.SuppressFinalize(gch[i]);
break;
}
break;
}
if (readerTestType != ReaderTestType.NoCloses)
{
con.Close();
con.Open(); // Close and open, to re-assure collection!
}
SqlCommand verificationCmd = con.CreateCommand();
verificationCmd.CommandText = COMMAND_STATUS;
using (SqlDataReader rdr = verificationCmd.ExecuteReader())
{
rdr.Read();
int connections = (int)rdr.GetValue(0);
rdr.NextResult();
rdr.Read();
int requests = (int)rdr.GetValue(0);
switch (executeType)
{
case ExecuteType.ExecuteScalar:
case ExecuteType.ExecuteNonQuery:
// 1 for connection, 1 for command
Assert.True(connections == 2, "Failure - incorrect number of connections for ExecuteScalar! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ExecuteScalar! #requests: " + requests);
break;
case ExecuteType.ExecuteReader:
switch (readerTestType)
{
case ReaderTestType.ReaderClose:
case ReaderTestType.ReaderDispose:
case ReaderTestType.ConnectionClose:
// 1 for connection, 1 for command
Assert.True(connections == 2, "Failure - Incorrect number of connections for ReaderClose / ReaderDispose / ConnectionClose! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ReaderClose/ReaderDispose/ConnectionClose! #requests: " + requests);
break;
case ReaderTestType.ReaderGC:
switch (gcType)
{
case GCType.Wait:
// 1 for connection, 1 for open reader
Assert.True(connections == 2, "Failure - incorrect number of connections for ReaderGCWait! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ReaderGCWait! #requests: " + requests);
break;
case GCType.NoWait:
// 1 for connection, 1 for open reader
Assert.True(connections == 2, "Failure - incorrect number of connections for ReaderGCNoWait! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ReaderGCNoWait! #requests: " + requests);
break;
}
break;
case ReaderTestType.NoCloses:
// 1 for connection, 1 for current command, 1 for 0 based array offset, plus i for open readers
Assert.True(connections == (3 + i), "Failure - incorrect number of connections for NoCloses: " + connections);
// 1 for current command, 1 for 0 based array offset, plus i open readers
Assert.True(requests == (2 + i), "Failure - incorrect number of requests for NoCloses: " + requests);
break;
}
break;
}
}
}
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
GCType s = (GCType)value;
return(s == (GCType)int.Parse(parameter.ToString()));
}
public ETWEventClrGCStart(GCStartTraceData gcStartTraceData) : base(gcStartTraceData)
{
Reason = gcStartTraceData.Reason;
Type = gcStartTraceData.Type;
}
private static void StartProcessingEvents()
{
// See https://github.com/dotnet/coreclr/blob/775003a4c72f0acc37eab84628fcef541533ba4e/src/pal/prebuilt/inc/mscoree.h#L294-L315
session.Source.Clr.RuntimeStart += runtimeData =>
{
if (ProcessIdsUsedInRuns.Contains(runtimeData.ProcessID) == false)
{
return;
}
lock (ConsoleLock)
{
Console.WriteLine("\nCONCURRENT_GC = {0}, SERVER_GC = {1}",
(runtimeData.StartupFlags & StartupFlags.CONCURRENT_GC) == StartupFlags.CONCURRENT_GC,
(runtimeData.StartupFlags & StartupFlags.SERVER_GC) == StartupFlags.SERVER_GC);
}
};
session.Source.Clr.GCAllocationTick += allocationData =>
{
if (ProcessIdsUsedInRuns.Contains(allocationData.ProcessID) == false)
{
return;
}
if (startTime == 0)
{
startTime = allocationData.TimeStampRelativeMSec;
}
stopTime = allocationData.TimeStampRelativeMSec;
totalBytesAllocated += allocationData.AllocationAmount;
lock (ConsoleLock)
{
if (allocationData.AllocationAmount > 200000)
{
Console.Write("o");
}
else
{
Console.Write(".");
}
}
};
GCType lastGCType = 0;
int lastGen = 0;
double gcStart = 0;
session.Source.Clr.GCStart += startData =>
{
if (ProcessIdsUsedInRuns.Contains(startData.ProcessID) == false)
{
return;
}
if (startTime == 0)
{
startTime = startData.TimeStampRelativeMSec;
}
lastGCType = startData.Type;
lastGen = startData.Depth;
gcStart = startData.TimeStampRelativeMSec;
IncrementGCCollectionCounts(startData);
var colourToUse = GetColourForGC(startData.Depth);
lock (ConsoleLock)
{
if (startData.Type == GCType.ForegroundGC || startData.Type == GCType.NonConcurrentGC)
{
// Make the FG coloured/highlighted
Console.ForegroundColor = colourToUse;
Console.BackgroundColor = ConsoleColor.Black;
}
else // GCType.BackgroundGC
{
// Make the BG coloured/highlighted
Console.ForegroundColor = ConsoleColor.Black;
Console.BackgroundColor = colourToUse;
}
Console.Write(startData.Depth);
Console.ResetColor();
}
};
session.Source.Clr.GCStop += stopData =>
{
if (ProcessIdsUsedInRuns.Contains(stopData.ProcessID) == false)
{
return;
}
stopTime = stopData.TimeStampRelativeMSec;
// If we don't have a matching start event, don't calculate the GC time
if (gcStart == 0)
{
return;
}
var gcTime = stopData.TimeStampRelativeMSec - gcStart;
timeInGc += gcTime;
lock (BinningLock)
{
binning[lastGen].Add(gcTime);
}
};
//In a typical blocking GC (this means all ephemeral GCs and full blocking GCs) the event sequence is very simple:
//GCSuspendEE_V1 Event
//GCSuspendEEEnd_V1 Event <– suspension is done
//GCStart_V1 Event
//GCEnd_V1 Event <– actual GC is done
//GCRestartEEBegin_V1 Event
//GCRestartEEEnd_V1 Event <– resumption is done.
double pauseStart = 0;
session.Source.Clr.GCSuspendEEStop += suspendData =>
{
if (ProcessIdsUsedInRuns.Contains(suspendData.ProcessID) == false)
{
return;
}
pauseStart = suspendData.TimeStampRelativeMSec;
};
session.Source.Clr.GCRestartEEStop += restartData =>
{
if (ProcessIdsUsedInRuns.Contains(restartData.ProcessID) == false)
{
return;
}
stopTime = restartData.TimeStampRelativeMSec;
// Only display this if the GC Type is Foreground, (Background is different!!)
// 0x0 - NonConcurrentGC - Blocking garbage collection occurred outside background garbage collection.
// 0x1 - BackgroundGC - Background garbage collection.
// 0x2 - ForegroundGC - Blocking garbage collection occurred during background garbage collection.
if (lastGCType == GCType.BackgroundGC)
{
return;
}
// If we don't have a matching start event, don't calculate the "pause" time
if (pauseStart == 0)
{
return;
}
var pauseDurationMSec = restartData.TimeStampRelativeMSec - pauseStart;
var pauseText = new StringBuilder();
while (pauseDurationMSec > 100)
{
pauseText.Append('█');
pauseDurationMSec -= 100;
}
if (pauseDurationMSec > 75)
{
pauseText.Append('█');
}
else if (pauseDurationMSec > 50)
{
pauseText.Append('▓');
}
else if (pauseDurationMSec > 25)
{
pauseText.Append('▒');
}
else
{
pauseText.Append("░");
}
totalGcPauseTime += pauseDurationMSec;
if (pauseDurationMSec > largestGcPause)
{
largestGcPause = pauseDurationMSec;
}
lock (ConsoleLock)
{
Console.ResetColor();
Console.Write(pauseText.ToString());
}
};
session.Source.Process();
}
private static (Summary, IConfig, Job)? ConditionalRun(Type benchmarkType, string[] args, Options options, GCType gcType, Runtime runtime, bool coldStart)
{
var config = DefaultConfig.Instance.WithOptions(ConfigOptions.Default);
//if (Debugger.IsAttached) {
config = config.WithOptions(ConfigOptions.DisableOptimizationsValidator);
//}
if (options.Runners.Count != 0)
{
var patterns = CreatePatterns(options.Runners);
var filters = patterns.Select(runner =>
new NameFilter(runner.IsMatch)
).Cast <IFilter>();
var disjunction = new DisjunctionFilter(filters.ToArray());
config = config.AddFilter(disjunction);
}
if (options.DiagnoseCpu)
{
config = config.AddDiagnoser(CpuDiagnoser.Default);
}
if (options.DiagnoseMemory)
{
config = config.AddDiagnoser(MemoryDiagnoser.Default);
}
if (options.DiagnoseInlining)
{
config = config.AddDiagnoser(new InliningDiagnoser());
}
if (options.DiagnoseTailCall)
{
config = config.AddDiagnoser(new TailCallDiagnoser());
}
if (options.DiagnoseEtw)
{
config = config.AddDiagnoser(new EtwProfiler());
}
//config.AddJob(Job.InProcess);
Job job;
if (Debugger.IsAttached || CurrentOptions.InProcess)
{
job = Job.InProcess
.WithGcServer(gcType == GCType.Server)
.WithRuntime(runtime)
.WithEnvironmentVariables(
new EnvironmentVariable("DOTNET_TieredCompilation", "0"),
new EnvironmentVariable("BENCHIE_ARGS", string.Join(" ", args))
)
.WithStrategy(coldStart ? RunStrategy.ColdStart : RunStrategy.Throughput);
}
else
{
job = Job.Default
.WithGcServer(gcType == GCType.Server)
.WithRuntime(runtime)
.WithEnvironmentVariables(
new EnvironmentVariable("DOTNET_TieredCompilation", "0"),
new EnvironmentVariable("BENCHIE_ARGS", string.Join(" ", args))
)
.WithStrategy(coldStart ? RunStrategy.ColdStart : RunStrategy.Throughput);
}
//if (typeof(TBenchmark) == typeof(Benchmarks.Premultiply)) {
// job = job.WithMinIterationCount(60).WithMaxIterationCount(400);
//}
string name = $"{gcType}.{runtime}.{(coldStart ? "cold" : "warm")}";
config = config.AddJob(job);
config = config.WithArtifactsPath(Path.Combine(config.ArtifactsPath, name));
{
List <Type> baseTypes = new();
Type? baseType = benchmarkType;
while (baseType is not null)
{
baseTypes.Add(baseType);
baseType = baseType.BaseType;
}
foreach (var type in baseTypes.ReverseF())
{
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(type.TypeHandle);
}
}
GC.Collect(int.MaxValue, GCCollectionMode.Forced, blocking: true, compacting: true);
var summary = BenchmarkRunner.Run(benchmarkType, config);
return(summary, config, job);
}
private static ((Summary, IConfig, Job)?, (Summary, IConfig, Job)?)? ConditionalRun(Type benchmarkType, string[] args, Options options, GCType gcType, Runtime runtime)
{
if (CurrentOptions.Cold)
{
return(
ConditionalRun(benchmarkType, args, options, gcType, runtime, coldStart: true),
ConditionalRun(benchmarkType, args, options, gcType, runtime, coldStart: false)
);
}
else
{
return(
null,
ConditionalRun(benchmarkType, args, options, gcType, runtime, coldStart: false)
);
}
}
private static void GCType_AddAdditionalMembersTo(GCType gcType, NativeNamespaceTranslator namespaceTranslator)
{
// This method is called through reflection when this type's corresponding GCType is populated.
NodeTechnique method = gcType.AddDefaultNodeTechnique(NameOfDefaultTechnique, Default);
//inputs
method.AddArgumentDefinition(NameOfUpdateObject, typeof(Feature[]), "null", "The nodes to upadte with the timer" );
method.AddArgumentDefinition(NameOfInterval, typeof(double), "25", "The update time in milliseconds");
//outputs
method.AddArgumentDefinition(NameOfReset, typeof(bool), "true", "The reset state (true/false)", NodePortRole.TechniqueOutputOnly);
method.AddArgumentDefinition(NameOfFrame, typeof(int), "0", "The current frame", NodePortRole.TechniqueOutputOnly);
}
private static void TestMARSSessionPooling(string caseName, string connectionString, CommandType commandType,
ExecuteType executeType, ReaderTestType readerTestType, GCType gcType)
{
SqlCommand[] cmd = new SqlCommand[CONCURRENT_COMMANDS];
SqlDataReader[] gch = new SqlDataReader[CONCURRENT_COMMANDS];
using (SqlConnection con = new SqlConnection(connectionString))
{
con.Open();
for (int i = 0; i < CONCURRENT_COMMANDS; i++)
{
// Prepare all commands
cmd[i] = con.CreateCommand();
switch (commandType)
{
case CommandType.Text:
cmd[i].CommandText = _COMMAND_SQL;
cmd[i].CommandTimeout = 120;
break;
case CommandType.StoredProcedure:
cmd[i].CommandText = _COMMAND_RPC;
cmd[i].CommandTimeout = 120;
cmd[i].CommandType = CommandType.StoredProcedure;
break;
}
}
for (int i = 0; i < CONCURRENT_COMMANDS; i++)
{
switch (executeType)
{
case ExecuteType.ExecuteScalar:
cmd[i].ExecuteScalar();
break;
case ExecuteType.ExecuteNonQuery:
cmd[i].ExecuteNonQuery();
break;
case ExecuteType.ExecuteReader:
if (readerTestType != ReaderTestType.ReaderGC)
{
gch[i] = cmd[i].ExecuteReader();
}
switch (readerTestType)
{
case ReaderTestType.ReaderClose:
{
gch[i].Dispose();
break;
}
case ReaderTestType.ReaderDispose:
gch[i].Dispose();
break;
case ReaderTestType.ReaderGC:
gch[i] = null;
WeakReference weak = OpenReaderThenNullify(cmd[i]);
GC.Collect();
if (gcType == GCType.Wait)
{
GC.WaitForPendingFinalizers();
Assert.False(weak.IsAlive, "Error - target still alive!");
}
break;
case ReaderTestType.ConnectionClose:
GC.SuppressFinalize(gch[i]);
con.Close();
con.Open();
break;
case ReaderTestType.NoCloses:
GC.SuppressFinalize(gch[i]);
break;
}
break;
}
if (readerTestType != ReaderTestType.NoCloses)
{
con.Close();
con.Open(); // Close and open, to re-assure collection!
}
using (SqlCommand verificationCmd = con.CreateCommand())
{
verificationCmd.CommandText = COMMAND_STATUS;
using (SqlDataReader rdr = verificationCmd.ExecuteReader())
{
rdr.Read();
int connections = (int)rdr.GetValue(0);
int spid1 = (Int16)rdr.GetValue(1);
rdr.NextResult();
rdr.Read();
int requests = (int)rdr.GetValue(0);
int spid2 = (Int16)rdr.GetValue(1);
switch (executeType)
{
case ExecuteType.ExecuteScalar:
case ExecuteType.ExecuteNonQuery:
// 1 for connection, 1 for command
Assert.True(connections == 2, "Failure - incorrect number of connections for ExecuteScalar! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ExecuteScalar! #requests: " + requests);
break;
case ExecuteType.ExecuteReader:
switch (readerTestType)
{
case ReaderTestType.ReaderClose:
case ReaderTestType.ReaderDispose:
case ReaderTestType.ConnectionClose:
// 1 for connection, 1 for command
Assert.True(connections == 2, "Failure - Incorrect number of connections for ReaderClose / ReaderDispose / ConnectionClose! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ReaderClose/ReaderDispose/ConnectionClose! #requests: " + requests);
break;
case ReaderTestType.ReaderGC:
switch (gcType)
{
case GCType.Wait:
// 1 for connection, 1 for open reader
Assert.True(connections == 2, "Failure - incorrect number of connections for ReaderGCWait! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ReaderGCWait! #requests: " + requests);
break;
case GCType.NoWait:
// 1 for connection, 1 for open reader
Assert.True(connections == 2, "Failure - incorrect number of connections for ReaderGCNoWait! #connections: " + connections);
// only 1 executing
Assert.True(requests == 1, "Failure - incorrect number of requests for ReaderGCNoWait! #requests: " + requests);
break;
}
break;
case ReaderTestType.NoCloses:
// 1 for connection, 1 for current command, 1 for 0 based array offset, plus i for open readers
Assert.True(connections == (3 + i), "Failure - incorrect number of connections for NoCloses: " + connections +
"\ni: " + i + " :::: requests: " + requests + " :::: spid1: " + spid1 + " ::::: spid2: " + spid2);
// 1 for current command, 1 for 0 based array offset, plus i open readers
Assert.True(requests == (2 + i), "Failure - incorrect number of requests for NoCloses: " + requests +
"\ni: " + i + " :::: connections: " + connections + " :::: spid1: " + spid1 + " ::::: spid2: " + spid2);
break;
}
break;
}
}
}
}
}
}
public static void GCRequest(int gen = -1, GCType type = GCType.GCOptimized)
{
GCWorker._GCRequested = true;
GCWorker._GCGen = gen;
GCWorker._GCType = type;
}
