ProcessorCount

134 references to ProcessorCount

dotnet-svcutil-lib (5)

FrameworkFork\System.ServiceModel\Internals\System\Runtime\SynchronizedPool.cs (1)

339return Environment.ProcessorCount;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\TransportDefaults.cs (3)

214return 12 * Environment.ProcessorCount; 219return 2 * Environment.ProcessorCount; 235return 12 * Environment.ProcessorCount;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\UdpConstants.cs (1)

41public static readonly long MaxPendingMessagesTotalSize = 1024 * 1024 * Environment.ProcessorCount; // 512 * 2K messages per processor

GenerateDocumentationAndConfigFiles (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Metrics (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Metrics.Legacy (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Microsoft.AspNetCore.Components.Server (1)

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequencePool.cs (1)

55: this(Environment.ProcessorCount * 2, ArrayPool<byte>.Create(80 * 1024, 100))

Microsoft.AspNetCore.Server.HttpSys (2)

HttpSysOptions.cs (2)

19internal static readonly int DefaultMaxAccepts = 5 * Environment.ProcessorCount; 75/// The default is 5 times the number of processors as returned by <see cref="Environment.ProcessorCount" />.

Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (2)

SchedulerBenchmark.cs (1)

20private static readonly int IOQueueCount = Math.Min(Environment.ProcessorCount, 16);

src\Servers\Kestrel\Transport.Sockets\src\Internal\IOQueue.cs (1)

88int processorCount = Environment.ProcessorCount;

Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (2)

NamedPipeTransportOptions.cs (2)

18/// Defaults to <see cref="Environment.ProcessorCount" /> rounded down and clamped between 1 and 16. 20public int ListenerQueueCount { get; set; } = Math.Min(Environment.ProcessorCount, 16);

Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets (3)

Internal\IOQueue.cs (1)

88int processorCount = Environment.ProcessorCount;

SocketConnectionFactoryOptions.cs (1)

36/// Defaults to a value based on and limited to <see cref="Environment.ProcessorCount" />.

SocketTransportOptions.cs (1)

31/// Defaults to a value based on and limited to <see cref="Environment.ProcessorCount" />.

Microsoft.Build (1)

BackEnd\Components\ProjectCache\ProjectCacheService.cs (1)

35private static readonly ParallelOptions s_parallelOptions = new() { MaxDegreeOfParallelism = Environment.ProcessorCount };

Microsoft.Build.Engine.UnitTests (3)

ProjectCache\ProjectCacheTests.cs (3)

420MaxNodeCount = Environment.ProcessorCount 429MaxNodeCount = Environment.ProcessorCount 746MaxNodeCount = Environment.ProcessorCount,

Microsoft.Build.Framework (1)

NativeMethods.cs (1)

494int numberOfCpus = Environment.ProcessorCount;

Microsoft.CodeAnalysis (5)

Collections\CachingFactory.cs (1)

200Environment.ProcessorCount * 2);

DiagnosticAnalyzer\AnalyzerDriver.cs (1)

333private readonly int _workerCount = Environment.ProcessorCount;

InternalUtilities\StringTable.cs (1)

94var pool = new ObjectPool<StringTable>(pool => new StringTable(pool), Environment.ProcessorCount * 2);

InternalUtilities\TextKeyedCache.cs (1)

88Environment.ProcessorCount * 4);

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.Analyzers (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Microsoft.CodeAnalysis.AnalyzerUtilities (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Microsoft.CodeAnalysis.BannedApiAnalyzers (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Microsoft.CodeAnalysis.CodeStyle (8)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

94var pool = new ObjectPool<StringTable>(pool => new StringTable(pool), Environment.ProcessorCount * 2);

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\Logger.LogBlock.cs (1)

17private static readonly ObjectPool<RoslynLogBlock> s_pool = new(() => new RoslynLogBlock(s_pool!), Math.Min(Environment.ProcessorCount * 8, 256));

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (5)

40/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 58/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 218/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 236/// <remarks>The operation will execute at most <see cref="Environment.ProcessorCount"/> operations in parallel.</remarks> 378private static int DefaultDegreeOfParallelism => Environment.ProcessorCount;

Microsoft.CodeAnalysis.Collections.Package (1)

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (1)

Diagnostics\DiagnosticAnalyzerTests.cs (1)

1406if (Environment.ProcessorCount <= 1)

Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (4)

InteractiveSessionTests.cs (4)

417Assert.Equal(Environment.ProcessorCount, result); 457Assert.Equal(Environment.ProcessorCount, script.EvaluateAsync().Result); 466Assert.Equal(Environment.ProcessorCount, state.Result.ReturnValue); 469Assert.Equal(Environment.ProcessorCount, state.Result.ReturnValue);

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (1)

Symbols\Source\CompletionTests.cs (1)

123Parallel.For(0, Math.Max(1, Environment.ProcessorCount - 1), t =>

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider (1)

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (1)

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.InteractiveHost (1)

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.PooledObjects.Package (1)

ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.PublicApiAnalyzers (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Microsoft.CodeAnalysis.ResxSourceGenerator (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Microsoft.CodeAnalysis.Test.Utilities (1)

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

1131Assert.True(Environment.ProcessorCount > 1, "This analyzer is intended to be used only in a concurrent environment.");

Microsoft.CodeAnalysis.Threading.Package (1)

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.CodeAnalysis.UnitTests (1)

Text\StringTextDecodingTests.cs (1)

220var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2 };

Microsoft.CodeAnalysis.Workspaces (3)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

94var pool = new ObjectPool<StringTable>(pool => new StringTable(pool), Environment.ProcessorCount * 2);

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Log\Logger.LogBlock.cs (1)

17private static readonly ObjectPool<RoslynLogBlock> s_pool = new(() => new RoslynLogBlock(s_pool!), Math.Min(Environment.ProcessorCount * 8, 256));

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (3)

src\Compilers\Core\Portable\InternalUtilities\StringTable.cs (1)

94var pool = new ObjectPool<StringTable>(pool => new StringTable(pool), Environment.ProcessorCount * 2);

src\Compilers\Core\Portable\InternalUtilities\TextKeyedCache.cs (1)

88Environment.ProcessorCount * 4);

src\Dependencies\PooledObjects\ObjectPool`1.cs (1)

110: this(factory, Environment.ProcessorCount * 2, trimOnFree)

Microsoft.DotNet.SignTool (1)

src\BatchSignUtil.cs (1)

47_repackParallelism = repackParallelism != 0 ? repackParallelism : Environment.ProcessorCount;

Microsoft.Extensions.Diagnostics.ResourceMonitoring (1)

Windows\WindowsSnapshotProvider.cs (1)

112internal static int GetCpuUnits() => Environment.ProcessorCount;

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (2)

Windows\WindowsSnapshotProviderTests.cs (2)

48Assert.Equal(Environment.ProcessorCount, provider.Resources.GuaranteedCpuUnits); 49Assert.Equal(Environment.ProcessorCount, provider.Resources.MaximumCpuUnits);

Microsoft.Extensions.ObjectPool (2)

DefaultObjectPool.cs (1)

30: this(policy, Environment.ProcessorCount * 2)

DefaultObjectPoolProvider.cs (1)

17public int MaximumRetained { get; set; } = Environment.ProcessorCount * 2;

Microsoft.ML.AutoML (1)

AutoMLExperiment\IPerformanceMonitor.cs (1)

125var cpuUsageInTotal = cpuUsedMs / (Environment.ProcessorCount * _checkIntervalInMilliseconds);

Microsoft.ML.Data (5)

Data\DataViewUtils.cs (1)

100int conc = Math.Max(2, Environment.ProcessorCount - 1);

DataLoadSave\Binary\BinaryLoader.cs (3)

783_threads = Math.Max(1, args.Threads ?? (Environment.ProcessorCount / 2)); 849_threads = Math.Max(1, Environment.ProcessorCount / 2); 857_threads = Math.Max(1, Environment.ProcessorCount / 2);

DataLoadSave\Binary\BinarySaver.cs (1)

667Task[] compressionThreads = new Task[Environment.ProcessorCount];

Microsoft.ML.FastTree (3)

FastTree.cs (1)

185InitializeThreads(FastTreeTrainerOptions.NumberOfThreads ?? Environment.ProcessorCount);

GamTrainer.cs (1)

604ThreadTaskManager.Initialize(GamTrainerOptions.NumberOfThreads ?? Environment.ProcessorCount);

SumupPerformanceCommand.cs (1)

99_parallel = args.Parallel ?? Environment.ProcessorCount;

Microsoft.ML.KMeansClustering (1)

KMeansPlusPlusTrainer.cs (1)

278int maxThreads = Environment.ProcessorCount / 2;

Microsoft.ML.Mkl.Components (1)

SymSgdClassificationTrainer.cs (1)

705int numThreads = _options.NumberOfThreads ?? Environment.ProcessorCount;

Microsoft.ML.Recommender (2)

MatrixFactorizationTrainer.cs (2)

366_threads = options.NumberOfThreads ?? Environment.ProcessorCount; 408_threads = args.NumberOfThreads ?? Environment.ProcessorCount;

Microsoft.ML.StandardTrainers (5)

Standard\LogisticRegression\LbfgsPredictorBase.cs (2)

469int numThreads = !UseThreads ? 1 : (NumThreads ?? Environment.ProcessorCount); 570int numThreads = !UseThreads ? 1 : (NumThreads ?? Environment.ProcessorCount);

Standard\SdcaBinary.cs (1)

141=> Math.Min(8, Math.Max(1, Environment.ProcessorCount / 2));

Standard\SdcaRegression.cs (1)

171=> Math.Min(2, Math.Max(1, Environment.ProcessorCount / 2));

Standard\StochasticTrainerBase.cs (1)

48=> Math.Min(8, Math.Max(1, Environment.ProcessorCount / 2));

Microsoft.NET.StringTools (1)

WeakStringCache.Concurrent.cs (1)

21_stringsByHashCode = new ConcurrentDictionary<int, StringWeakHandle>(Environment.ProcessorCount, _initialCapacity);

MSBuildTaskHost (1)

NativeMethods.cs (1)

494int numberOfCpus = Environment.ProcessorCount;

Roslyn.Diagnostics.Analyzers (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

RunTests (1)

TestRunner.cs (1)

81var max = _options.Sequential ? 1 : (int)(Environment.ProcessorCount * 1.5);

System.Collections.Concurrent (4)

System\Collections\Concurrent\ConcurrentDictionary.cs (1)

2079private static int DefaultConcurrencyLevel => Environment.ProcessorCount;

System\Collections\Concurrent\PartitionerStatic.cs (3)

186long rangeSize = (long)(range / (Environment.ProcessorCount * CoreOversubscriptionRate)); 240int rangeSize = (int)(range / (Environment.ProcessorCount * CoreOversubscriptionRate)); 581int fillBufferMultiplier = (Environment.ProcessorCount > 4) ? 4 : 1;

System.Data.Odbc (1)

src\libraries\Common\src\System\Data\ProviderBase\DbConnectionFactory.cs (1)

26private static readonly Task<DbConnectionInternal?>[] s_pendingOpenNonPooled = new Task<DbConnectionInternal?>[Environment.ProcessorCount];

System.Diagnostics.DiagnosticSource (2)

System\Diagnostics\Metrics\CounterAggregator.cs (1)

21private readonly PaddedDouble[] _deltas = new PaddedDouble[Math.Min(Environment.ProcessorCount, 8)];

System\Diagnostics\Metrics\RuntimeMetrics.cs (1)

145() => (long)Environment.ProcessorCount,

System.Linq.Parallel (1)

System\Linq\Parallel\Scheduling\Scheduling.cs (1)

34internal static readonly int DefaultDegreeOfParallelism = Math.Min(Environment.ProcessorCount, MAX_SUPPORTED_DOP);

System.Net.Sockets (2)

System\Net\Sockets\SocketAsyncEngine.Unix.cs (2)

50return Environment.ProcessorCount; 58return Math.Max(1, (int)Math.Round(Environment.ProcessorCount / (double)coresPerEngine));

System.Private.CoreLib (19)

src\libraries\System.Private.CoreLib\src\System\Buffers\SharedArrayPool.cs (2)

502/// <remarks>Defaults to int.MaxValue. Whatever value is returned will end up being clamped to <see cref="Environment.ProcessorCount"/>.</remarks> 508return Math.Min(partitionCount, Environment.ProcessorCount);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\RuntimeEventSource.cs (1)

121ProcessorCount(Environment.ProcessorCount);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\RuntimeEventSourceHelper.Unix.cs (1)

11Interop.Sys.GetCpuUtilization(ref s_cpuInfo) / Environment.ProcessorCount;

src\libraries\System.Private.CoreLib\src\System\Environment.cs (1)

44internal static bool IsSingleProcessor => ProcessorCount == 1;

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\PoolingAsyncValueTaskMethodBuilderT.cs (4)

289private static readonly PaddedReference[] s_perCoreCache = new PaddedReference[Environment.ProcessorCount]; 358Debug.Assert(s_perCoreCache.Length == Environment.ProcessorCount, $"{s_perCoreCache.Length} != {Environment.ProcessorCount}"); 359int i = (int)((uint)Thread.GetCurrentProcessorId() % (uint)Environment.ProcessorCount);

src\libraries\System.Private.CoreLib\src\System\Threading\LowLevelSpinWaiter.cs (1)

23int processorCount = Environment.ProcessorCount;

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.Blocking.cs (1)

319int processorCount = Environment.ProcessorCount;

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.cs (1)

123_minThreads = HasForcedMinThreads ? ForcedMinWorkerThreads : (short)Environment.ProcessorCount;

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.Unix.cs (1)

18Interop.Sys.GetCpuUtilization(ref _cpuInfo) / Environment.ProcessorCount;

src\libraries\System.Private.CoreLib\src\System\Threading\ReaderWriterLockSlim.cs (1)

1229if ((spinCount < 5) && (Environment.ProcessorCount > 1))

src\libraries\System.Private.CoreLib\src\System\Threading\SpinLock.cs (1)

351if (turn > Environment.ProcessorCount)

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\ConcurrentExclusiveSchedulerPair.cs (1)

64private static int DefaultMaxConcurrencyLevel => Environment.ProcessorCount;

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (2)

408Environment.ProcessorCount <= 32 ? 0 : 409(Environment.ProcessorCount + (ProcessorsPerAssignableWorkItemQueue - 1)) / ProcessorsPerAssignableWorkItemQueue;

src\libraries\System.Private.CoreLib\src\System\Threading\Timer.cs (1)

51var queues = new TimerQueue[Environment.ProcessorCount];

System.Reflection.Metadata (1)

System\Reflection\Internal\Utilities\ObjectPool`1.cs (1)

42: this(factory, Environment.ProcessorCount * 2)

System.Runtime.Caching (1)

System\Runtime\Caching\MemoryCache.cs (1)

359_storeCount = Environment.ProcessorCount;

System.Threading (1)

System\Threading\ReaderWriterLock.cs (1)

30private static readonly int DefaultSpinCount = Environment.ProcessorCount != 1 ? 500 : 0;

System.Threading.Tasks.Parallel (10)

System\Threading\Tasks\Parallel.cs (1)

950Environment.ProcessorCount :

System\Threading\Tasks\Parallel.ForEachAsync.cs (8)

System\Threading\Tasks\TaskReplicator.cs (1)

167return 100 + Random.Shared.Next(0, 50 * Environment.ProcessorCount);

Test.Utilities (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

Text.Analyzers (1)

src\RoslynAnalyzers\Utilities\Compiler\PooledObjects\ObjectPool.cs (1)

112: this(factory, Environment.ProcessorCount * 2)

VBCSCompiler (1)

src\Compilers\Server\VBCSCompiler\NamedPipeClientConnectionHost.cs (1)

69var listenCount = Math.Min(4, Environment.ProcessorCount);