private static ExperimentManager NewManager()
        {
            ReferenceExperiment reference = new ReferenceExperiment(
                ExperimentDefinition.Create("LinearEquationSolver.exe", ExperimentDefinition.LocalDiskContainerUri, "reference", "csv", "{0} 10", TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(0), "default"),
                1, 0.17);
            ExperimentManager manager = LocalExperimentManager.NewExperiments("measure" + Guid.NewGuid(), reference, domainResolver);

            return(manager);
        }
 private static ExperimentManager OpenManager(ExperimentManager old)
 {
     if (old is LocalExperimentManager)
     {
         LocalExperimentManager local   = (LocalExperimentManager)old;
         ExperimentManager      manager = LocalExperimentManager.OpenExperiments(local.Directory, domainResolver);
         return(manager);
     }
     else
     {
         throw new ArgumentException("Unsupported type of manager");
     }
 }
예제 #3
0
        static int Main(string[] args)
        {
            if (args.Length < 5 || args.Length > 7)
            {
                return(PrintSyntax());
            }

            int  k    = 0;
            bool init = false;

            if (args[k] == "--init")
            {
                if (args.Length != 7)
                {
                    return(PrintSyntax());
                }
                init = true;
                k++;
            }
            else
            {
                if (args.Length != 5)
                {
                    return(PrintSyntax());
                }
            }

            string executable            = args[k++];
            string arguments             = args[k++];
            string benchmarkContainerUri = ExperimentDefinition.LocalDiskContainerUri;
            string benchmarkDirectory    = args[k++];
            string category  = args[k++];
            string extension = args[k++];

            int    repetitions    = 1;
            double referenceValue = 1.0;

            if (init)
            {
                repetitions = int.Parse(args[k++], CultureInfo.InvariantCulture);
            }

            TimeSpan             timeout    = TimeSpan.FromHours(1);
            ExperimentDefinition definition = ExperimentDefinition.Create(executable, benchmarkContainerUri, benchmarkDirectory, extension, arguments, timeout, TimeSpan.FromSeconds(0), Measurement.Domain.Default.Name, category: category);
            string version = GetVersion(executable);

            if (init)
            {
                Print(String.Format("Initializing environment..."));
            }
            else
            {
                Print(String.Format("Measuring performance of {0} {1}...\n", executable, version));
            }

            IDomainResolver domainResolver = new DomainResolver(new[] { Measurement.Domain.Default });

            if (init)
            {
                var reference             = new ReferenceExperiment(definition, repetitions, referenceValue);
                ExperimentManager manager = LocalExperimentManager.NewExperiments("measure", reference, domainResolver);
            }
            else
            {
                ExperimentManager manager = LocalExperimentManager.OpenExperiments("measure", domainResolver);
                Run(manager, definition).Wait();
            }

            return(0);
        }