public Kerncentrale(ThreadingType threadingType) { this.reactors = new List <Reactor>(); this.threadingType = threadingType; this.InitializeTmpReactors(); this.InitialiseTimer(); }
public static void ConfigureRollingSizeFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\Log4Net.{threadingType}.RollingSizeFile.log"; File.Delete(logFileName); PatternLayout patternLayout = new PatternLayout { ConversionPattern = LogOutputTemplate }; patternLayout.ActivateOptions(); var rollingFileAppender = new RollingFileAppender { File = logFileName, Layout = patternLayout, MaxSizeRollBackups = Parameters.MaxArchiveFiles, MaximumFileSize = Parameters.Log4NetArchiveAboveString, RollingStyle = RollingFileAppender.RollingMode.Size, StaticLogFileName = true }; rollingFileAppender.ActivateOptions(); Hierarchy.Root.AddAppender(rollingFileAppender); Hierarchy.Root.Level = Level.Info; Hierarchy.Configured = true; }
public static void ConfigureRollingSizeFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\NLog.{threadingType}.RollingSizeFile.log"; File.Delete(logFileName); var config = new LoggingConfiguration(); var rollingSizeLogFileTarget = new FileTarget("RollingSizeLogFileTarget") { FileName = logFileName, Layout = LogOutputTemplate, KeepFileOpen = true, // Improves performance drastically (by default is set to false) ArchiveAboveSize = Parameters.ArchiveAboveBytes, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = Parameters.MaxArchiveFiles }; config.AddTarget(rollingSizeLogFileTarget); config.AddRule(LogLevel.Info, LogLevel.Fatal, rollingSizeLogFileTarget); LogManager.Configuration = config; }
public static void ConfigureOptimizedSimpleFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\NLog.{threadingType}.Optimized.SimpleFile.log"; File.Delete(logFileName); var config = new LoggingConfiguration(); var simpleLogFileTarget = new FileTarget("SimpleLogFileTarget") { FileName = logFileName, Layout = LogOutputTemplate, KeepFileOpen = true, // Improves performance drastically (by default is set to false) }; var asyncTargetWrapper = new AsyncTargetWrapper() { Name = "AsyncTargetWrapper", BatchSize = 50, FullBatchSizeWriteLimit = 1, OptimizeBufferReuse = true, OverflowAction = AsyncTargetWrapperOverflowAction.Grow, QueueLimit = 10000, TimeToSleepBetweenBatches = 0, WrappedTarget = simpleLogFileTarget }; config.AddTarget(asyncTargetWrapper); config.AddRule(LogLevel.Info, LogLevel.Fatal, asyncTargetWrapper); LogManager.Configuration = config; }
//public void Do<T, U, V, W, X, R>(F<T, U, V, W, X, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, R>(F1<T, U, V, W, X, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, R>(F2<T, U, V, W, X, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, R>(F3<T, U, V, W, X, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, R>(F4<T, U, V, W, X, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, R>(F5<T, U, V, W, X, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F1<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F2<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F3<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F4<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F5<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, R>(F6<T, U, V, W, X, Y, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F1<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F2<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F3<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F4<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F5<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F6<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } //public void Do<T, U, V, W, X, Y, Z, R>(F7<T, U, V, W, X, Y, Z, R> m) { PrivateDo(m); } #endregion internal void SyncContext(Delegate d) { threadingType = ThreadingType.SyncContext; @delegate = d; VerifyDelegate(); //TODO: more tests here... see above }
private Chord NewChord(ThreadingType threadingType) { var chord = NewChord(); chord.ThreadingType = threadingType; return(chord); }
public static void ConfigureSimpleFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\Log4Net.{threadingType}.SimpleFile.log"; File.Delete(logFileName); PatternLayout patternLayout = new PatternLayout { ConversionPattern = LogOutputTemplate }; patternLayout.ActivateOptions(); var simpleFileAppender = new FileAppender { File = logFileName, Layout = patternLayout }; simpleFileAppender.ActivateOptions(); Hierarchy.Root.AddAppender(simpleFileAppender); Hierarchy.Root.Level = Level.Info; Hierarchy.Configured = true; }
//public void Continue<T, U, V, W, X, R>(F<T, U, V, W, X, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, R>(F1<T, U, V, W, X, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, R>(F2<T, U, V, W, X, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, R>(F3<T, U, V, W, X, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, R>(F4<T, U, V, W, X, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, R>(F5<T, U, V, W, X, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F1<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F2<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F3<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F4<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F5<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, R>(F6<T, U, V, W, X, Y, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F1<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F2<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F3<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F4<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F5<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F6<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } //public void Continue<T, U, V, W, X, Y, Z, R>(F7<T, U, V, W, X, Y, Z, R> m) { PrivateContinue(m); } #endregion internal void PrivateDo(Delegate d) { threadingType = ThreadingType.Sync; @delegate = d; VerifyDelegate(); if (!(this is SyncChord)) { throw new IncompatibleSchedulingException("Use \"Continue\" to run an async chord on the incoming thread."); } }
//public void Spawn<T, U, V, W, X, R>(F<T, U, V, W, X, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, R>(F1<T, U, V, W, X, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, R>(F2<T, U, V, W, X, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, R>(F3<T, U, V, W, X, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, R>(F4<T, U, V, W, X, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, R>(F5<T, U, V, W, X, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F1<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F2<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F3<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F4<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F5<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, R>(F6<T, U, V, W, X, Y, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F1<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F2<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F3<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F4<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F5<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F6<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } //public void Spawn<T, U, V, W, X, Y, Z, R>(F7<T, U, V, W, X, Y, Z, R> m) { PrivateSpawn(m); } #endregion internal void PrivateContinue(Delegate d) { //TODO: only valid for async chords mChord is AsyncChord... threadingType = ThreadingType.Continue; @delegate = d; VerifyDelegate(); if (!(this is AsyncChord)) { throw new IncompatibleSchedulingException("Use \"Do\" to run an sync chord on the thread of the primary method."); } }
public static void ReportTestResults(ThreadingType threadingType, LogFileType logFileType) { Console.WriteLine("-------------------------------------------------------------------------------------------------------------------------------------------------"); Console.WriteLine(); Console.WriteLine($"'{threadingType} -> {logFileType}' test FINISHED: {DateTime.Now}"); if (Parameters.OutputEnvironmentInfoAfterRun) { EnvironmentInfoUtil.OutputEnvironmentInfo(); } }
//public void Pool<T, U, V, W, X, R>(F<T, U, V, W, X, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, R>(F1<T, U, V, W, X, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, R>(F2<T, U, V, W, X, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, R>(F3<T, U, V, W, X, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, R>(F4<T, U, V, W, X, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, R>(F5<T, U, V, W, X, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F1<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F2<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F3<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F4<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F5<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, R>(F6<T, U, V, W, X, Y, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F1<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F2<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F3<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F4<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F5<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F6<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } //public void Pool<T, U, V, W, X, Y, Z, R>(F7<T, U, V, W, X, Y, Z, R> m) { PrivatePool(m); } #endregion internal void PrivateSpawn(Delegate d) { //TODO: only valid for async chords mChord is AsyncChord... threadingType = ThreadingType.Spawn; @delegate = d; VerifyDelegate(); if (!(this is AsyncChord)) { throw new IncompatibleSchedulingException("Only asynchronous chords can be spawned."); } }
public void Copy(GitSettings settings) { AutoStage = settings.AutoStage; AutoFetch = settings.AutoFetch; ExternalsType = (ExternalsTypeEnum)settings.ExternalsType; ExternalProgram = settings.ExternalProgram; CredentialsManager = settings.CredentialsManager; ProjectStatusOverlayDepth = settings.ProjectStatusOverlayDepth; ShowEmptyFolders = settings.ShowEmptyFolders; Threading = (settings.GitStatusMultithreaded ? DefalutThreadingType : 0); UseGavatar = settings.UseGavatar; MaxCommitTextAreaSize = settings.MaxCommitTextAreaSize; DetectRenames = settings.DetectRenames ? RenameTypeEnum.All : RenameTypeEnum.None; }
public static Logger ConfigureSimpleFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\Serilog.{threadingType}.SimpleFile.log"; File.Delete(logFileName); var logger = new LoggerConfiguration() .WriteTo.File( logFileName, outputTemplate: LogOutputTemplate) .Enrich.WithThreadId() .Enrich.WithProperty("LoggerName", "PerformanceTests") .MinimumLevel.Information() .CreateLogger(); return(logger); }
public static Logger ConfigureRollingSizeFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\Serilog.{threadingType}.RollingSizeFile.log"; File.Delete(logFileName); var logger = new LoggerConfiguration() .WriteTo.File( logFileName, outputTemplate: LogOutputTemplate, rollOnFileSizeLimit: true, fileSizeLimitBytes: Parameters.ArchiveAboveBytes, retainedFileCountLimit: Parameters.MaxArchiveFiles) .Enrich.WithThreadId() .Enrich.WithProperty("LoggerName", "PerformanceTests") .MinimumLevel.Information() .CreateLogger(); return(logger); }
public static void ConfigureSimpleFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\NLog.{threadingType}.SimpleFile.log"; File.Delete(logFileName); var config = new LoggingConfiguration(); var simpleLogFileTarget = new FileTarget("SimpleLogFileTarget") { FileName = logFileName, Layout = LogOutputTemplate, KeepFileOpen = true, // Improves performance drastically (by default is set to false) }; config.AddTarget(simpleLogFileTarget); config.AddRuleForOneLevel(LogLevel.Info, simpleLogFileTarget); LogManager.Configuration = config; }
public static void ConfigureOptimizedSimpleFileLogger(ThreadingType threadingType) { var logFileName = $"{Parameters.RootLogsDirectory}\\Log4Net.{threadingType}.Optimized.SimpleFile.log"; File.Delete(logFileName); PatternLayout patternLayout = new PatternLayout { ConversionPattern = LogOutputTemplate }; patternLayout.ActivateOptions(); var simpleFileAppender = new FileAppender { File = logFileName, Layout = patternLayout }; simpleFileAppender.ActivateOptions(); var asyncBufferingForwarderAppender = new AsyncBufferingForwardingAppender() { Lossy = false, BufferSize = 512, Fix = FixFlags.ThreadName | FixFlags.Message | FixFlags.Exception, IdleTime = 500 }; asyncBufferingForwarderAppender.AddAppender(simpleFileAppender); asyncBufferingForwarderAppender.ActivateOptions(); Hierarchy.Root.AddAppender(asyncBufferingForwarderAppender); Hierarchy.Root.Level = Level.Info; Hierarchy.Configured = true; }
/// <summary> /// Updates what threading type will be used /// </summary> /// <param name="type"></param> private void UpdateThreadingType(ThreadingType type) { (App.Current as App).threadingType = type; }
/// <summary> /// set the selected TreadingType /// </summary> /// <param name="threadingType"></param> public void SetSelectedThreadingType(ThreadingType threadingType) { this.selectedThreadingType = threadingType; }
public static void ReportStartedTest(ThreadingType threadingType, LogFileType logFileType) { Console.WriteLine($"'{threadingType} -> {logFileType}' test STARTED: {DateTime.Now}"); }