private static AzureBenchmarkResult ToAzureResult(BenchmarkResult b, AzureBenchmarkResult externalOutput)
        {
            AzureBenchmarkResult azureResult = AzureExperimentStorage.ToAzureBenchmarkResult(b);

            if (externalOutput != null)
            {
                azureResult.StdOut = externalOutput.StdOut;
                azureResult.StdOutExtStorageIdx = externalOutput.StdOutExtStorageIdx;

                azureResult.StdErr = externalOutput.StdErr;
                azureResult.StdErrExtStorageIdx = externalOutput.StdErrExtStorageIdx;
            }
            else
            {
                b.StdOut.Position  = 0;
                azureResult.StdOut = Utils.StreamToString(b.StdOut, true);
                azureResult.StdOutExtStorageIdx = string.Empty;

                b.StdErr.Position  = 0;
                azureResult.StdErr = Utils.StreamToString(b.StdErr, true);
                azureResult.StdErrExtStorageIdx = string.Empty;
            }

            return(azureResult);
        }
        public static AzureExperimentManager Open(string connectionString)
        {
            var    cs = new BatchConnectionString(connectionString);
            string batchAccountName = cs.BatchAccountName;
            string batchUrl         = cs.BatchURL;
            string batchAccessKey   = cs.BatchAccessKey;

            cs.RemoveKeys(BatchConnectionString.KeyBatchAccount, BatchConnectionString.KeyBatchURL, BatchConnectionString.KeyBatchAccessKey);
            string storageConnectionString = cs.ToString();

            AzureExperimentStorage storage = new AzureExperimentStorage(storageConnectionString);

            if (batchAccountName != null)
            {
                return(Open(storage, batchUrl, batchAccountName, batchAccessKey));
            }
            return(OpenWithoutStart(storage));
        }
        public AzureExperimentResults(AzureExperimentStorage storage, int expId, AzureBenchmarkResult[] results, string etag) : base(expId, Parse(results, storage))
        {
            this.expId   = expId;
            this.storage = storage;
            this.etag    = etag;

            var benchmarks = Benchmarks;

            externalOutputs = new Dictionary <BenchmarkResult, AzureBenchmarkResult>();
            for (int i = 0; i < results.Length; i++)
            {
                var r = results[i];
                if (!string.IsNullOrEmpty(r.StdOutExtStorageIdx) || !string.IsNullOrEmpty(r.StdErrExtStorageIdx))
                {
                    externalOutputs.Add(benchmarks[i], r);
                }
            }
        }
        private static BenchmarkResult[] Parse(AzureBenchmarkResult[] results, AzureExperimentStorage storage)
        {
            if (storage == null)
            {
                throw new ArgumentNullException(nameof(storage));
            }
            if (results == null)
            {
                throw new ArgumentNullException(nameof(results));
            }

            int n = results.Length;

            BenchmarkResult[] benchmarks = new BenchmarkResult[n];
            for (int i = 0; i < n; i++)
            {
                benchmarks[i] = storage.ParseAzureBenchmarkResult(results[i]);
            }
            return(benchmarks);
        }
Exemple #5
0
        public AzureSummaryManager(string storageConnectionString, IDomainResolver domainResolver)
        {
            if (domainResolver == null)
            {
                throw new ArgumentNullException(nameof(domainResolver));
            }

            var cs = new StorageAccountConnectionString(storageConnectionString).ToString();

            storage = new AzureExperimentStorage(cs);

            storageAccount   = CloudStorageAccount.Parse(cs);
            blobClient       = storageAccount.CreateCloudBlobClient();
            summaryContainer = blobClient.GetContainerReference(summaryContainerName);

            var cloudEntityCreationTasks = new Task[] {
                summaryContainer.CreateIfNotExistsAsync()
            };

            resolveDomain = domainResolver;

            Task.WaitAll(cloudEntityCreationTasks);
        }
 /// <summary>
 /// Creates a manager in a mode when it can open data but not start new experiments.
 /// </summary>
 public static AzureExperimentManager OpenWithoutStart(AzureExperimentStorage storage)
 {
     return(new AzureExperimentManager(storage));
 }
 public static AzureExperimentManager Open(AzureExperimentStorage storage, string batchUrl, string batchAccName, string batchKey)
 {
     return(new AzureExperimentManager(storage, batchUrl, batchAccName, batchKey));
 }
        public static async Task <AzureExperimentManager> New(AzureExperimentStorage storage, ReferenceExperiment reference, string batchUrl, string batchAccName, string batchKey)
        {
            await storage.SaveReferenceExperiment(reference);

            return(new AzureExperimentManager(storage, batchUrl, batchAccName, batchKey));
        }
 protected AzureExperimentManager(AzureExperimentStorage storage)
 {
     this.storage     = storage;
     this.batchCreds  = null;
     this.BatchPoolID = DefaultPoolID;
 }
 protected AzureExperimentManager(AzureExperimentStorage storage, string batchUrl, string batchAccName, string batchKey)
 {
     this.storage     = storage;
     this.batchCreds  = new BatchSharedKeyCredentials(batchUrl, batchAccName, batchKey);
     this.BatchPoolID = DefaultPoolID;
 }
        public override async Task <bool> TryDelete(IEnumerable <BenchmarkResult> toRemove)
        {
            if (toRemove == null)
            {
                throw new ArgumentNullException(nameof(toRemove));
            }

            var benchmarks = Benchmarks;
            var removeSet  = new HashSet <BenchmarkResult>(toRemove);

            if (removeSet.Count == 0)
            {
                return(true);
            }

            int n = benchmarks.Length;
            List <AzureBenchmarkResult> newAzureResults = new List <AzureBenchmarkResult>(n);
            List <BenchmarkResult>      newResults      = new List <BenchmarkResult>(n);
            List <AzureBenchmarkResult> deleteOuts      = new List <AzureBenchmarkResult>();

            for (int i = 0; i < n; i++)
            {
                var b = benchmarks[i];
                if (!removeSet.Contains(b)) // remains
                {
                    var azureResult = AzureExperimentStorage.ToAzureBenchmarkResult(b);
                    newAzureResults.Add(azureResult);
                    newResults.Add(b);
                }
                else // to be removed
                {
                    removeSet.Remove(b);

                    AzureBenchmarkResult ar;
                    if (externalOutputs.TryGetValue(b, out ar))
                    {
                        deleteOuts.Add(ar);
                    }
                }
            }
            if (removeSet.Count != 0)
            {
                throw new ArgumentException("Some of the given results to remove do not belong to the experiment results");
            }

            // Updating blob with results table
            bool success = await Upload(newAzureResults.ToArray());

            if (!success)
            {
                return(false);
            }

            // Update benchmarks array
            Replace(newResults.ToArray());

            // Deleting blobs with output
            foreach (var ar in deleteOuts)
            {
                try
                {
                    var _ = storage.DeleteOutputs(ar);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception when deleting output: {0}", ex));
                }
            }

            return(true);
        }
        public override async Task <Dictionary <BenchmarkResult, BenchmarkResult> > TryUpdateStatus(IEnumerable <BenchmarkResult> toModify, ResultStatus status)
        {
            if (toModify == null)
            {
                throw new ArgumentNullException(nameof(toModify));
            }

            var mod = new Dictionary <BenchmarkResult, BenchmarkResult>();

            foreach (var oldRes in toModify)
            {
                mod.Add(oldRes, null);
            }
            if (mod.Count == 0)
            {
                return(mod);
            }

            int n                  = Benchmarks.Length;
            var newBenchmarks      = (BenchmarkResult[])Benchmarks.Clone();
            var newAzureBenchmarks = new AzureBenchmarkResult[n];

            for (int i = 0; i < n; i++)
            {
                var b = newBenchmarks[i];

                if (mod.ContainsKey(b))
                {
                    if (b.Status != status) // updating status of this result
                    {
                        newBenchmarks[i] = new BenchmarkResult(b.ExperimentID, b.BenchmarkFileName,
                                                               b.AcquireTime, b.NormalizedRuntime, b.TotalProcessorTime, b.WallClockTime,
                                                               b.PeakMemorySizeMB,
                                                               status, // <-- new status
                                                               b.ExitCode, b.StdOut, b.StdErr, b.Properties);

                        newAzureBenchmarks[i] = AzureExperimentStorage.ToAzureBenchmarkResult(newBenchmarks[i]);

                        mod[b] = newBenchmarks[i];
                    }
                    else // status is as required already
                    {
                        newAzureBenchmarks[i] = AzureExperimentStorage.ToAzureBenchmarkResult(b);
                        mod.Remove(b);
                    }
                }
                else // result doesn't change
                {
                    newAzureBenchmarks[i] = AzureExperimentStorage.ToAzureBenchmarkResult(b);
                }
            }

            if (mod.Count == 0)
            {
                return(new Dictionary <BenchmarkResult, BenchmarkResult>());               // no changes
            }
            foreach (var item in mod)
            {
                if (item.Value == null)
                {
                    throw new ArgumentException("Some of the given results to update do not belong to the experiment results");
                }
            }

            bool success = await Upload(newAzureBenchmarks);

            if (!success)
            {
                return(null);
            }

            // Update benchmarks array
            Replace(newBenchmarks.ToArray());

            return(mod);
        }