public async Task BuildDuplicatesResolverView(int[] ids, bool resolveTimeouts, bool resolveSameTime, bool resolveSlowest, bool resolveInErrors)
        {
            var handle = uiService.StartIndicateLongOperation("Resolving duplicates...");

            try
            {
                for (int i = 0; i < ids.Length; i++)
                {
                    int eid = ids[i];

                    bool resolved = false;
                    do
                    {
                        var results = await manager.GetResults(eid);

                        var duplicates = DuplicateResolver.Resolve(results.Benchmarks, resolveTimeouts, resolveSameTime, resolveSlowest, resolveInErrors, conflicts => uiService.ResolveDuplicatedResults(eid, conflicts));

                        if (duplicates == null)
                        {
                            uiService.ShowInfo("Duplicates resolution cancelled.", "Resolution cancelled");
                            return; // cancelling operation
                        }
                        if (duplicates.Length > 0)
                        {
                            resolved = await results.TryDelete(duplicates);

                            if (resolved)
                            {
                                uiService.ShowInfo(string.Format("{0} item(s) removed from the experiment {1}.", duplicates.Length, eid), "Duplicates resolved");
                            }
                            else
                            {
                                if (!uiService.AskYesNo(
                                        string.Format("Results of the experiment {0} have been changed since resolution started. Resolve again?", eid),
                                        "Conflict when saving results"))
                                {
                                    return;
                                }
                            }
                        }
                        else
                        {
                            resolved = true;
                            uiService.ShowInfo("There are no duplicates in the experiment " + eid, "No duplicates");
                        }
                    } while (!resolved);
                }
            }
            catch (Exception ex)
            {
                uiService.ShowError(ex, "Error when resolving duplicates");
            }
            finally
            {
                uiService.StopIndicateLongOperation(handle);
            }
        }
Beispiel #2
0
        protected async Task <TableRow> GetRow(int id)
        {
            ExperimentViewModel x = timeline.GetExperiment(id);
            var s = await expManager.GetResults(id, fn => fn == txtFilename.Text);

            TableRow r = new TableRow();

            r.ID             = x.Id.ToString();
            r.SubmissionTime = x.SubmissionTime.ToString();
            r.IsFinished     = x.IsFinished;
            r.Results        = s.Benchmarks;
            return(r);
        }
Beispiel #3
0
        public async Task GetResultsFromCloud()
        {
            ValidatesConnectionString();
            AzureExperimentStorage storage = new AzureExperimentStorage(storageConnectionString);
            AzureExperimentManager manager = AzureExperimentManager.OpenWithoutStart(storage);

            Stopwatch sw1     = Stopwatch.StartNew();
            var       results = await manager.GetResults(TestExperimentId);

            Assert.AreEqual(TestExperimentId, results.ExperimentId);
            sw1.Stop();
            Trace.WriteLine("1st time: " + sw1.ElapsedMilliseconds);
            Assert.AreEqual(103814, results.Benchmarks.Length);

            /// Again, should read from local disk:
            Stopwatch sw2      = Stopwatch.StartNew();
            var       results2 = await manager.GetResults(TestExperimentId);

            sw2.Stop();
            Trace.WriteLine("2nd time: " + sw2.ElapsedMilliseconds);

            Assert.AreEqual(103814, results2.Benchmarks.Length);
        }