protected virtual void CalculCompleted(IComputable computable) { if (CalculCompletedEvent != null) { ComputableEventArgs eventArgs = new ComputableEventArgs(); eventArgs.Computable = computable; CalculCompletedEvent(this, eventArgs); } }
//**************************************************************************************************** private void AddFront(IComputable obj) { m_c++; if (m_c == 1) m_top = m_bottom = new Element(obj, null); else { Element t = new Element(obj, null); m_bottom.m_next = t; m_bottom = t; } }
private void ParallelCompute(IComputable computable) { computable.Compute(); CountCalculated++; base.CalculCompleted(computable); if (CountCalculated >= this.ListComputable.Count && !AreAllCalculCompleted) base.AllCalculCompleted(); }
protected override void CalculCompleted(IComputable computable) { CountCalculated++; base.CalculCompleted(computable); if (!IsThreadAlive()) { return; } ThreadingBaseMethod threadingMethod = this.ListThread.Find(t => t.computable == computable); this.ListThread.Remove(threadingMethod); CreateNewThread(1); }
public void Mul(IComputable computer) { var mul = computer.Mul(1, 2); Assert.Equal(2, mul); }
public MefTest(IComputable computer) { this._computer = computer; }
private ComputationResultVM Count(List <ReceivedMeasurement> measurements, IComputable analyzeComponent, AnalysisVM viewmodel) { analyzeComponent.Analyze(measurements, viewmodel); return(analyzeComponent.GetResult()); }
public static void DisplayAnswer(IComputable computable) { Console.WriteLine(computable.Problem); Console.WriteLine(computable.AnswerDesc + " " + computable.Answer.ToString()); Console.WriteLine(); }
public ThreadingNativeMethod(ThreadManagerBase threadManager, IComputable computable) : base(threadManager, computable) { }
public ThreadingBaseMethod(ThreadManagerBase threadManager, IComputable computable) { this.computable = computable; this.threadManager = threadManager; }
internal Element(IComputable obj, Element next) { m_o = obj; m_next = next; }
static void Main(string[] args) { #region Program definitions const int problemSize = 12; var theSolver = new IComputable[] { new SlimCPU4bits13(), //new SlimCPU5bits(), //new SlimCPUCoalesced(), //new SlimCPUUntweaked(), //new SlimGPUQueue(), //new SlimCPUGPU(), //new SuperSlimGPUBreakthrough() }; #endregion #region creditentials var email = string.Empty; var password = new SecureString(); Console.WriteLine("Send email notifications? (y/n)"); if (Console.ReadKey().KeyChar.ToString().ToLower().Equals("y")) { Console.WriteLine(); Console.WriteLine("Please enter notification email: (will send to self)"); email = Console.ReadLine(); Console.WriteLine($"Please enter the creditentials for the selected email"); foreach (var ch in Console.ReadLine()) { password.AppendChar(ch); } Console.Clear(); Console.WriteLine("Creditentials saved"); } #endregion //Gpu.Default.Device.Print(); const int problemSeed = 1234567; var random = new Random(problemSeed); var watch = new Stopwatch(); var version = theSolver.GetType().Namespace; var csvBuilder = new StringBuilder("problemsize,problemcount"); foreach (var solver in theSolver) { csvBuilder.Append(",").Append(solver.GetType().Name); } //var resultsDictionary = new List<ComputationResult>(); var sizeIncrease = 1;// Math.Pow(2, 1d / 8d); var initialProblemSamplingCount = 1 << 21; var maximalProblemCount = 1 << 25; double doublePrecisionN = initialProblemSamplingCount; var problems = new Problem[0]; for (int n = (int)doublePrecisionN; n < maximalProblemCount; n = (int)Math.Round(doublePrecisionN *= sizeIncrease)) //for (int i = 0; i < 10; i++) { Console.WriteLine(); Console.WriteLine(); Console.ForegroundColor = ConsoleColor.DarkGray; Console.WriteLine($"{n} problems"); Console.ResetColor(); Console.WriteLine(); var latestCPUPerformance = TimeSpan.FromSeconds(1); var latestGPUPerformance = TimeSpan.FromSeconds(1); csvBuilder.AppendLine(); csvBuilder.Append(problemSize).Append(",").Append(n); if (problems.Length != n) { problems = new Problem[n]; Problem.FillArrayOfProblems(problems, n, problemSize, problemSeed + n); } foreach (var solver in theSolver) { if (computeLoopUsing(solver)) { return; } ; } bool computeLoopUsing(IComputable solver) { //var problems = new[] { Problem.GenerateWorstCase(problemSize) }; //var problems = Problem.GetArrayOfProblems(16, 3, 123456).Skip(10).Take(6); bool Compute(IComputable localSolver, Problem[] localProblems, ComputationResult[] localResults) { var result = localSolver.Verify(problems, 0, problems.Length, localSolver.GetBestParallelism()); if (result >= 0) { File.AppendAllText($@"./cernyFailed.csv", problems[result].ToString()); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine($"Cerny Conjecture is false."); Console.WriteLine($"Problem description: {problems[result]}"); Console.ResetColor(); new Notifications.OpenBrowserTab().Notify(problems[result]); new Notifications.SendEmail().Notify(problems[result], email, password); return(true); } else { return(false); } } var results = new ComputationResult[problems.Length]; if (solver is SlimCPUGPU) { ((SlimCPUGPU)solver).SetCPUPart((float)(latestCPUPerformance.TotalMilliseconds / (latestCPUPerformance.TotalMilliseconds + latestGPUPerformance.TotalMilliseconds))); } watch.Restart(); if (Compute(solver, problems, results)) { return(true); } watch.Stop(); var computationElapsed = watch.Elapsed; if (solver is SlimCPU4bits13) { latestCPUPerformance = computationElapsed; } else if (solver is SlimGPUQueue) { latestGPUPerformance = computationElapsed; } //var summary = new ComputationResultSummary(); csvBuilder.Append(",").Append(Math.Round(n / computationElapsed.TotalSeconds)); //var benchmarkkedResults = results.Where(result => result.benchmarkResult != null && result.benchmarkResult.benchmarkedTime != null && result.benchmarkResult.totalTime != null); //var computationToTotalFraction = benchmarkedResults.Sum(result => result.benchmarkResult.benchmarkedTime.TotalMilliseconds) // / benchmarkedResults.Sum(result => result.benchmarkResult.totalTime.TotalMilliseconds); //Console.WriteLine(computationToTotalFraction); //watch.Reset(); //watch.Start(); //if (!( // results.Zip(problems, (result, problem) => // !result.isSynchronizable || Verify.VerifyValidityOfSynchronizingWord(problem, result, degreeOfParallelism) // ).All(isOK => isOK) // && // results.Zip(problems, (result, problem) => // Verify.VerifyCernyConjecture(problem, result) // ).All(isOK => isOK) // )) //{ // throw new Exception("Incorrect algorithm"); //} //watch.Stop(); var verificationElapsed = watch.Elapsed; //resultsDictionary.AddRange(results); Console.ForegroundColor = ConsoleColor.Green; Console.Write(solver.GetType()); Console.ResetColor(); Console.Write($" using {solver.GetBestParallelism()} parallelism in {computationElapsed.TotalMilliseconds:F2}ms. Problems per second: "); Console.ForegroundColor = ConsoleColor.Green; Console.Write($"{n / computationElapsed.TotalSeconds:F2}"); Console.ResetColor(); Console.WriteLine($". Time per problem {computationElapsed.TotalMilliseconds / n}ms"); //Console.WriteLine($"{n} problems verified using {degreeOfParallelism} processors in {verificationElapsed.TotalMilliseconds:F2}ms. " + // $"Verifications per second: {n / verificationElapsed.TotalSeconds:F2}. " + // $"Time per verification {verificationElapsed.TotalMilliseconds / n:F5}ms"); //Console.WriteLine($"Summary: {results.Average(result => result.isSynchronizable ? 1 : 0) * 100:F2}% synchronizability, " + // $"{results.Where(result => result.isSynchronizable).Average(result => result.shortestSynchronizingWordLength):F2} average length of a synchronizing word"); //var lessThanOrEqualTo = 10; //Console.WriteLine($"fraction of less or equal to {lessThanOrEqualTo} is {results.Select(result => result.shortestSynchronizingWordLength <= lessThanOrEqualTo ? 1 : 0).Average()}"); //#region Histogram //var histogram = results // .Where(result => result.isSynchronizable) // .Histogram(30, result => result.shortestSynchronizingWordLength); //foreach (var bin in histogram) //{ // Console.Write($"{Math.Round(bin.RepresentativeValue)} (count: {bin.Count}): "); // for (int i = 0; i < bin.Count * 500 / n || (i == 0 && bin.Count > 0); i++) // { // Console.Write("-"); // } // Console.WriteLine(); //} //Console.WriteLine(); //#endregion #region Benchmark //Console.WriteLine($"benchmarked time took {100 * fractionOfTime:F2}%"); #endregion //Console.WriteLine(results.Average(result => result.queueBreadth)); //save appropriate statistical data to a file from resultsDictionary System.IO.File.WriteAllText($@"./gpgpu.csv", csvBuilder.ToString()); Console.WriteLine(); Console.WriteLine(); return(false); } } }
private void RefreshProgression(int count, IComputable computable) { progressBar.Value = count; //if (btnShowMapResolving.Text == BUTTON_MAP_OFF) computable.Draw(_gMap); }
public ThreadingBackgroundWorkerMethod(ThreadManagerBackgroundWorker threadManager, IComputable computable) : base(threadManager, computable) { }
/// <summary> /// Creates an instance of this computable with the required input. /// </summary> /// <param name="input"></param> public ToString(IComputable <T> input) { Input = input; }
/// <summary> /// Creates an instance of the if-then-else-computable with the condition-, then- and else-computable. /// </summary> /// <param name="condition">The condition-computable.</param> /// <param name="thenComputable">The then-computable.</param> /// <param name="elseComputable">The else-computable.</param> public If(IBooleanComputable condition, IComputable <T> thenComputable, IComputable <T> elseComputable) { Condition = condition; ThenComputable = thenComputable; ElseComputable = elseComputable; }