示例#1
0
 public MemoryBenchmarkSetting(MemoryMetric metric, Assertion assertion)
 {
     Metric        = metric;
     Assertion     = assertion;
     AssertionType = AssertionType.Total;
     MetricName    = new MemoryMetricName(metric);
 }
示例#2
0
        public static MemoryMetric ToBaseMetric(MemoryMetric metric, out double factor)
        {
            switch (metric)
            {
            case MemoryMetric.Bit:
                factor = 1;
                return(MemoryMetric.Bit);

            case MemoryMetric.Kilobit:
                factor = 1E3;
                return(MemoryMetric.Bit);

            case MemoryMetric.Megabit:
                factor = 1E6;
                return(MemoryMetric.Bit);

            case MemoryMetric.Gigabit:
                factor = 1E9;
                return(MemoryMetric.Bit);

            case MemoryMetric.Terrabit:
                factor = 1E12;
                return(MemoryMetric.Bit);

            case MemoryMetric.Petabit:
                factor = 1E15D;
                return(MemoryMetric.Bit);

            case MemoryMetric.Byte:
                factor = 1;
                return(MemoryMetric.Byte);

            case MemoryMetric.Kilobyte:
                factor = 1E3;
                return(MemoryMetric.Byte);

            case MemoryMetric.Megabyte:
                factor = 1E6;
                return(MemoryMetric.Byte);

            case MemoryMetric.Gigabyte:
                factor = 1E9;
                return(MemoryMetric.Byte);

            case MemoryMetric.Terrabyte:
                factor = 1E12;
                return(MemoryMetric.Byte);

            case MemoryMetric.PetaByte:
                factor = 1E15;
                return(MemoryMetric.Byte);

            default:
                throw new NotSupportedException(metric.ToString());
            }
        }
示例#3
0
        public static double ConvertMemoryMetric(double quanity, MemoryMetric fromMetric, MemoryMetric toMetric)
        {
            double fromBaseFactor;
            var    fromBaseMetric = ToBaseMetric(fromMetric, out fromBaseFactor);

            double toBaseFactor;
            var    toBaseMetric = ToBaseMetric(toMetric, out toBaseFactor);

            double conversionFactor;

            switch (fromBaseMetric)
            {
            case MemoryMetric.Bit:
                switch (toBaseMetric)
                {
                case MemoryMetric.Bit:
                    conversionFactor = 1;
                    break;

                case MemoryMetric.Byte:
                    conversionFactor = 1 / 8D;
                    break;

                default:
                    throw new NotSupportedException(fromBaseMetric.ToString());
                }

                break;

            case MemoryMetric.Byte:
                switch (toBaseMetric)
                {
                case MemoryMetric.Bit:
                    conversionFactor = 8D;
                    break;

                case MemoryMetric.Byte:
                    conversionFactor = 1;
                    break;

                default:
                    throw new NotSupportedException(fromBaseMetric.ToString());
                }
                break;

            default:
                throw new NotSupportedException(fromBaseMetric.ToString());
            }

            return((fromBaseFactor * quanity * conversionFactor) / toBaseFactor);
        }
示例#4
0
 public MemoryMetricName(MemoryMetric metric)
 {
     Metric = metric;
 }
示例#5
0
 public MemoryMetricName(MemoryMetric metric)
 {
     Metric = metric;
 }
 public MemoryAssertionAttribute(MemoryMetric metric, MustBe condition, double averageBytes) : base(metric)
 {
     Condition = condition;
     AverageBytes = averageBytes;
 }
 public MemoryMeasurementAttribute(MemoryMetric metric)
 {
     Metric = metric;
 }
 public MemoryAssertionAttribute(MemoryMetric metric, MustBe condition, double averageBytes) : base(metric)
 {
     Condition    = condition;
     AverageBytes = averageBytes;
 }
 public MemoryMeasurementAttribute(MemoryMetric metric)
 {
     Metric = metric;
 }