/// <summary> /// Returns a <see cref="DataSize"/> that is the highest value which will have a non-zero whole-number <see cref="Size"/> component. /// </summary> /// <param name="unit">When set to <see cref="SizeUnit.Bytes"/> the result will be a <code>B</code> type, when set to <see cref="SizeUnit.Bits"/> the result will be a <code>iB</code> type. If set to <code>null</code> the same base unit as the source value will be used.</param> /// <returns>A <see cref="DataSize"/> object.</returns> public DataSize GetLargestWholeSize(SizeUnit? unit = null) { var limit = 1000ul; if (unit == null) { unit = (SizeUnit)((int)Unit & 0x00FF); } if (unit == SizeUnit.Bits) { limit = 1024ul; } var iterations = 0; var currSize = (double)SizeInBytes; while (currSize >= limit) { currSize /= limit; iterations++; } return new DataSize(currSize, (SizeUnit)((iterations << 8) | ((int)unit & 0x00FF))); }
public FileSizeFilterSettings(SerializationInfo info, StreamingContext context) : base(info, context) { minimalSize__ = info.GetInt32("MinimalSize"); maximalSize__ = info.GetInt32("MaximalSize"); unit__ = (SizeUnit)info.GetInt32("SizeUnit"); }
public double GetSize(SizeUnit unit) { if (unit == SizeUnit.Bits) { return SizeInBytes * 8.0; } if (((int)unit & 0x03) == (int)SizeUnit.Bytes) { return SizeInBytes / Math.Pow(10, 3 * (((int)unit & 0xFF00) >> 8)); } return SizeInBytes / Math.Pow(2, 10 * (((int)unit & 0xFF00) >> 8)); }
private DataSize(double size, SizeUnit unit) { Unit = unit; if (unit == SizeUnit.Bits) { SizeInBytes = (uint)(size / 8); return; } if (((int)unit & 0x03) == (int)SizeUnit.Bytes) { SizeInBytes = (uint)(size * Math.Pow(10, 3 * (((int)unit & 0xFF00) >> 8))); return; } SizeInBytes = (uint)(size * Math.Pow(2, 10 * (((int)unit & 0xFF00) >> 8))); }
public void SizeUnit_should_have_equality_operators() { Assert.True(SizeUnit.Unlimited == SizeUnit.Unlimited); Assert.True(SizeUnit.NotSet == SizeUnit.NotSet); Assert.True(SizeUnit.Absolute(10) == SizeUnit.Absolute(10)); Assert.False(SizeUnit.Unlimited == SizeUnit.NotSet); Assert.False(SizeUnit.NotSet == SizeUnit.Absolute(10)); Assert.False(SizeUnit.Absolute(10) == SizeUnit.Unlimited); Assert.False(SizeUnit.Absolute(10) == SizeUnit.Absolute(11)); Assert.False(SizeUnit.Unlimited != SizeUnit.Unlimited); Assert.False(SizeUnit.NotSet != SizeUnit.NotSet); Assert.False(SizeUnit.Absolute(10) != SizeUnit.Absolute(10)); Assert.True(SizeUnit.Unlimited != SizeUnit.NotSet); Assert.True(SizeUnit.NotSet != SizeUnit.Absolute(10)); Assert.True(SizeUnit.Absolute(10) != SizeUnit.Unlimited); Assert.True(SizeUnit.Absolute(10) != SizeUnit.Absolute(11)); }
/// <summary> /// Gets the size of the byte. /// </summary> /// <param name="size">The size.</param> /// <param name="unit">The unit.</param> /// <returns></returns> public static long GetByteSize(int size, SizeUnit unit) { switch (unit) { case SizeUnit.Gb: return(size * SizeGb); case SizeUnit.Mb: return(size * SizeMb); case SizeUnit.Kb: return(size * SizeKb); case SizeUnit.b: return(size); default: return(size); } }
/// <summary> /// Gets the unit count. /// </summary> /// <param name="byteSize">Size of the byte.</param> /// <param name="unit">The unit.</param> /// <returns></returns> public static long GetUnitCount(long byteSize, SizeUnit unit) { switch (unit) { case SizeUnit.Gb: return(byteSize / SizeGb); case SizeUnit.Mb: return(byteSize / SizeMb); case SizeUnit.Kb: return(byteSize / SizeKb); case SizeUnit.b: return(byteSize); default: return(byteSize); } }
GetCurrentDiskSpaceTotalAndUsedPercentAllDrives(SizeUnit sizeUnit = SizeUnit.Bytes) { DriveInfo[] allDrives = DriveInfo.GetDrives(); var tuples = new List <(string, double, int)>(); for (int i = 0; i < allDrives.Length; i++) { if (!allDrives[i].IsReady) { continue; } var drivename = allDrives[i].Name; var totalSize = GetTotalDiskSpace(drivename, sizeUnit); var pctUsed = GetCurrentDiskSpaceUsedPercent(drivename); tuples.Add((drivename.Substring(0, 1), totalSize, pctUsed)); } return(tuples); }
public static string Abbreviation(this SizeUnit unit) { if (unit == SizeUnit.Bytes) { return("B"); } if (unit == SizeUnit.Bits) { return("b"); } var firstLetter = unit.ToString()[0] + ""; if (((int)unit & 0x00FF) == (int)SizeUnit.Bits) { return(firstLetter + "iB"); } return(firstLetter + "B"); }
internal static double GetInchValue(SizeUnit unit, double dpi, double value) { double result = 0; switch (unit) { case SizeUnit.Pixels: default: result = value / dpi; break; case SizeUnit.Inches: result = value; break; case SizeUnit.Cm: result = value / dpi; break; } return(result); }
public void Measure_should_use_Width_and_Height_if_provided(string width, string height, int expectedWidth, int expectedHeight, int desiredWidth, int desiredHeight) { var inputSize = new Size(15, 20); var fixedMeasureSize = new Size(20, 30); var receivedInputSize = Size.Empty; var component = new TestableComponent { Width = SizeUnit.Parse(width), Height = SizeUnit.Parse(height), OnMeasureCallback = x => { receivedInputSize = x; return(fixedMeasureSize); } }; component.Measure(inputSize, TestRendererContext.Instance); component.DesiredSize.ShouldBe(new Size(desiredWidth, desiredHeight)); receivedInputSize.ShouldBe(new Size(expectedWidth, expectedHeight)); }
public static ulong AsBytes(SizeUnit unit, uint size) { switch (unit) { case SizeUnit.B: return(size); case SizeUnit.KB: return(OneKb * size); case SizeUnit.MB: return(size * OneMb); case SizeUnit.GB: return(size * OneGb); case SizeUnit.TB: return(size * OneTb); } return(0); }
private static long ConvertToBytes(long value, SizeUnit unit) { switch (unit) { case SizeUnit.Bytes: return(value); case SizeUnit.Kilobytes: return(value * OneKb); case SizeUnit.Megabytes: return(value * OneMb); case SizeUnit.Gigabytes: return(value * OneGb); case SizeUnit.Terabytes: return(value * OneTb); default: throw new NotSupportedException("Not supported size unit: " + unit); } }
internal static double Convert(double size, SizeUnit currentUnit, SizeUnit TargetUnit) { if (currentUnit == TargetUnit) { return(size); //Em-Em, Pt-Pt, Px-Px } else if (currentUnit == SizeUnit.EMS) { return(ConvertFromEms((int)size, TargetUnit)); //Em-Pt, Em-Px } else if (TargetUnit == SizeUnit.EMS) { return(ConvertToEms(size, currentUnit)); //Pt-Em, Px-Em } else if (TargetUnit == SizeUnit.PIXELS) { return(size / 72.0 * 96); //Pt-Px } else { return(size * 96.0 / 72); //Px-Pt } }
private static double ConvertToSizeUnits(double amount, SizeUnit sizeUnit) { switch (sizeUnit) { case SizeUnit.Bytes: return(amount); case SizeUnit.Kilobytes: return(amount / 1024); case SizeUnit.Megabytes: return(amount / 1024 / 1024); case SizeUnit.Gigabytes: return(amount / 1024 / 1024 / 1024); case SizeUnit.Terabytes: return(amount / 1024 / 1024 / 1024 / 1024); default: return(amount); } }
public SizeInfo(long bytesSize) { if (bytesSize >= GbSize) { Size = Math.Round(bytesSize / GbSizeDivisor, 2); Unit = SizeUnit.GBYTE; } else if (bytesSize >= MbSize) { Size = Math.Round(bytesSize / MbSizeDivisor, 1); Unit = SizeUnit.MBYTE; } else if (bytesSize >= KbSize) { Size = Math.Round(bytesSize / KbSizeDivisor, 0); Unit = SizeUnit.KBYTE; } else { Size = bytesSize; Unit = SizeUnit.BYTE; } }
public long GetValue(SizeUnit requestedUnit) { switch (requestedUnit) { case SizeUnit.Bytes: return(valueInBytes); case SizeUnit.Kilobytes: return(valueInBytes / OneKb); case SizeUnit.Megabytes: return(valueInBytes / OneMb); case SizeUnit.Gigabytes: return(valueInBytes / OneGb); case SizeUnit.Terabytes: return(valueInBytes / OneTb); default: throw new NotSupportedException("Not supported size unit: " + unit); } }
public long GetValue(SizeUnit requestedUnit) { switch (requestedUnit) { case SizeUnit.Bytes: return(_valueInBytes); case SizeUnit.Kilobytes: return(_valueInBytes / OneKb); case SizeUnit.Megabytes: return(_valueInBytes / OneMb); case SizeUnit.Gigabytes: return(_valueInBytes / OneGb); case SizeUnit.Terabytes: return(_valueInBytes / OneTb); default: ThrowUnsupportedSize(); return(-1); // never hit } }
private void UnitSwitch_Click(object sender, EventArgs e) { var names = Enum.GetNames(typeof(SizeUnit)).ToList(); int i = names.Select(s => s.ToLower()).ToList().IndexOf(UnitSwitch.Text.ToLower()); SizeUnit = i < names.Count - 1 ? (SizeUnit)Enum.Parse(typeof(SizeUnit), names[i + 1]) : (SizeUnit)Enum.Parse(typeof(SizeUnit), names[0]); // go back to first SizeLength = sizeLength; // trigger set logic }
public static double GetTotalDiskSpace(string driveName, SizeUnit sizeUnit = SizeUnit.Bytes) { return(GetTotalDiskSpace(new DriveInfo(driveName), sizeUnit)); }
public DataSize(ulong sizeInBytes, SizeUnit unit) { Unit = unit; SizeInBytes = sizeInBytes; }
public static DataSize From(double size, SizeUnit unit) => new DataSize(size, unit);
internal SummaryTable(Summary summary, SummaryStyle style = null) { Summary = summary; if (summary.HasCriticalValidationErrors) { Columns = Array.Empty <SummaryTableColumn>(); ColumnCount = 0; FullHeader = Array.Empty <string>(); FullContent = Array.Empty <string[]>(); FullContentStartOfHighlightGroup = Array.Empty <bool>(); FullContentWithHeader = Array.Empty <string[]>(); IsDefault = Array.Empty <bool>(); return; } // Ensure we have all required data for styling style = style ?? summary.Style ?? SummaryStyle.Default; if (style.TimeUnit == null) { style = style.WithTimeUnit(TimeUnit.GetBestTimeUnit(summary.Reports.Where(r => r.ResultStatistics != null).Select(r => r.ResultStatistics.Mean) .ToArray())); } if (style.SizeUnit == null) { style = style.WithSizeUnit(SizeUnit.GetBestSizeUnit(summary.Reports.Select(r => r.GcStats.GetBytesAllocatedPerOperation(r.BenchmarkCase)).ToArray())); } var columns = summary.GetColumns(); ColumnCount = columns.Length; FullHeader = columns.Select(c => c.GetColumnTitle(style)).ToArray(); FullContent = summary.Reports.Select(r => columns.Select(c => c.GetValue(summary, r.BenchmarkCase, style)).ToArray()).ToArray(); IsDefault = columns.Select(c => summary.Reports.All(r => c.IsDefault(summary, r.BenchmarkCase))).ToArray(); var highlightGroupKeys = summary.BenchmarksCases.Select(b => b.Config.Orderer.GetHighlightGroupKey(b)).ToArray(); FullContentStartOfHighlightGroup = new bool[summary.Reports.Length]; if (highlightGroupKeys.Distinct().Count() > 1 && FullContentStartOfHighlightGroup.Length > 0) { FullContentStartOfHighlightGroup[0] = true; for (int i = 1; i < summary.Reports.Length; i++) { FullContentStartOfHighlightGroup[i] = highlightGroupKeys[i] != highlightGroupKeys[i - 1]; } } var logicalGroupKeys = summary.BenchmarksCases .Select(b => b.Config.Orderer.GetLogicalGroupKey(summary.BenchmarksCases, b)) .ToArray(); FullContentStartOfLogicalGroup = new bool[summary.Reports.Length]; if (logicalGroupKeys.Distinct().Count() > 1 && FullContentStartOfLogicalGroup.Length > 0) { FullContentStartOfLogicalGroup[0] = true; for (int i = 1; i < summary.Reports.Length; i++) { FullContentStartOfLogicalGroup[i] = logicalGroupKeys[i] != logicalGroupKeys[i - 1]; } } SeparateLogicalGroups = summary.Orderer.SeparateLogicalGroups; var full = new List <string[]> { FullHeader }; full.AddRange(FullContent); FullContentWithHeader = full.ToArray(); Columns = new SummaryTableColumn[columns.Length]; for (int i = 0; i < columns.Length; i++) { var column = columns[i]; bool hide = summary.ColumnHidingRules.Any(rule => rule.NeedToHide(column)); Columns[i] = new SummaryTableColumn(this, i, column, hide); } EffectiveSummaryStyle = style; }
static string GetMarkerSize(double value, SizeUnit sizeUnit) { //Halve the resulting size to get approximate same size as it would look under basic stylization return((SizeInMM(value, sizeUnit) / 2.0).ToString(CultureInfo.InvariantCulture)); }
public string ToString(SizeUnit unit) => $"{GetSize(unit)} {unit.Abbreviation()}";
public string ToString(SizeUnit sizeUnit) { var unitValue = SizeUnit.Convert(Bytes, SizeUnit.B, sizeUnit); return(unitValue.ToString("0.##", CultureInfo.InvariantCulture)); }
public SizeValue(long bytes, SizeUnit unit) : this(bytes * unit.ByteAmount) { }
private string Write95_SizeUnit(SizeUnit v) { switch (v) { case SizeUnit.Byte: return "Byte"; case SizeUnit.KiloByte: return "KiloByte"; case SizeUnit.MegaByte: return "MegaByte"; } long num = (long) v; throw base.CreateInvalidEnumValueException(num.ToString(CultureInfo.InvariantCulture), "Nomad.Commons.SizeUnit"); }
public SummaryStyle([CanBeNull] CultureInfo cultureInfo, bool printUnitsInHeader, SizeUnit sizeUnit, TimeUnit timeUnit, bool printUnitsInContent = true, bool printZeroValuesInContent = false, int maxParameterColumnWidth = DefaultMaxParameterColumnWidth, RatioStyle ratioStyle = RatioStyle.Value) { if (maxParameterColumnWidth < DefaultMaxParameterColumnWidth) { throw new ArgumentOutOfRangeException(nameof(maxParameterColumnWidth), $"{DefaultMaxParameterColumnWidth} is the minimum."); } CultureInfo = cultureInfo ?? DefaultCultureInfo.Instance; PrintUnitsInHeader = printUnitsInHeader; PrintUnitsInContent = printUnitsInContent; SizeUnit = sizeUnit; TimeUnit = timeUnit; PrintZeroValuesInContent = printZeroValuesInContent; MaxParameterColumnWidth = maxParameterColumnWidth; RatioStyle = ratioStyle; }
public static double GetTotalDiskSpace(DriveInfo driveInfo, SizeUnit sizeUnit = SizeUnit.Bytes) { long total = driveInfo.TotalSize; return(Math.Round(ConvertToSizeUnits(total, sizeUnit), 2)); }
public string ToString(string numberFormat, SizeUnit unit) => $"{GetSize(unit).ToString(numberFormat)} {unit.Abbreviation()}";
static string GetLineThickness(double value, SizeUnit unit) { return(SizeInMM(value, unit).ToString(CultureInfo.InvariantCulture)); }
public DataSize(ulong sizeInBytes) { Unit = SizeUnit.Bytes; SizeInBytes = sizeInBytes; }
public SizeUnitAttribute(SizeUnit unit) { Unit = unit; }
public void ParseArguments_Should_Handle_Unit_Argument(string argument, string value, SizeUnit expected, string message) { // ACT var parameters = Helper.ParseArguments("fileName", $"{argument}={value}"); // ASSERT parameters.FileSizeUnit.Should().Be(expected, message); }
public SummaryStyle WithSizeUnit(SizeUnit sizeUnit) => new SummaryStyle(PrintUnitsInHeader, sizeUnit, TimeUnit, PrintUnitsInContent);
public ApproximateSize(float value, SizeUnit unit) { Value = value; Unit = unit; }
public SummaryStyle WithSizeUnit(SizeUnit sizeUnit) => new SummaryStyle(CultureInfo, PrintUnitsInHeader, sizeUnit, TimeUnit, PrintUnitsInContent, PrintZeroValuesInContent, MaxParameterColumnWidth, RatioStyle);
private static void DisplayDiff(IEnumerable <Benchmark[]> allBenchmarks, IEnumerable <string> allNames) { // Use the first job's benchmarks as the reference for the rows: var firstBenchmarks = allBenchmarks.FirstOrDefault(); if (firstBenchmarks == null || firstBenchmarks.Length < 1) { return; } var summaries = new Dictionary <string, List <BenchmarkSummary> >(); foreach (var benchmark in firstBenchmarks) { summaries[benchmark.FullName] = new List <BenchmarkSummary>(); } foreach (var benchmarks in allBenchmarks) { foreach (var benchmark in benchmarks) { summaries[benchmark.FullName].Add(new BenchmarkSummary() { Name = benchmark.FullName, MeanNanoseconds = benchmark.Statistics.Mean, StandardErrorNanoseconds = benchmark.Statistics.StandardError, StandardDeviationNanoseconds = benchmark.Statistics.StandardDeviation, MedianNanoseconds = benchmark.Statistics.Median, Gen0 = benchmark.Memory?.Gen0Collections ?? 0, Gen1 = benchmark.Memory?.Gen1Collections ?? 0, Gen2 = benchmark.Memory?.Gen2Collections ?? 0, AllocatedBytes = benchmark.Memory?.BytesAllocatedPerOperation ?? 0 }); } } // Simplfy the benchmarks' names where possible to remove prefixes that // are all the same to reduce the width of the first column of the table // to the shortest unique string required across all benchmarks. var nameSegments = summaries.Keys.ToDictionary(key => key, value => value.Split('.')); while (true) { var areAllFirstSegmentsTheSame = nameSegments.Values .Select(segments => segments[0]) .Distinct() .Count() == 1; if (!areAllFirstSegmentsTheSame) { // The names cannot be simplified further break; } foreach (var pair in nameSegments) { nameSegments[pair.Key] = pair.Value.Skip(1).ToArray(); } } // Map the full names to their simplified name var simplifiedNames = nameSegments.ToDictionary(key => key.Key, value => string.Join(".", value.Value)); var anyAllocations = summaries.Values .SelectMany(list => list) .Select(summary => summary.AllocatedBytes) .Any(allocatedBytes => allocatedBytes > 0); // Name + baseline mean (firstBenchmarks) + (other benchmarks' mean * 2 (value + ratio)) + // baseline allocations + (other benchmarks' mean * 2 (value + ratio)) var otherCount = allNames.Count() - 1; var table = new ResultTable(1 + 1 + (anyAllocations ? 1 : 0) + (otherCount * (anyAllocations ? 4 : 2))); var firstName = allNames.First(); table.Headers.Add("benchmark"); table.Headers.Add($"mean ({firstName})"); foreach (var name in allNames.Skip(1)) { table.Headers.Add($"mean ({name})"); table.Headers.Add("ratio"); } if (anyAllocations) { table.Headers.Add($"allocated ({firstName})"); foreach (var name in allNames.Skip(1)) { table.Headers.Add($"allocated ({name})"); table.Headers.Add("ratio"); } } foreach (var benchmark in summaries.OrderBy(kvp => kvp.Key).Select(kvp => kvp.Value)) { var firstBenchmark = benchmark.First(); var simplifiedName = simplifiedNames[firstBenchmark.Name]; var benchmarks = summaries[firstBenchmark.Name]; var row = table.AddRow(); var cell = new Cell(); cell.Elements.Add(new CellElement() { Text = simplifiedName, Alignment = CellTextAlignment.Left }); row.Add(cell); AddCells(row, summary => summary.MeanNanoseconds, UnitType.Time, benchmarks); if (anyAllocations) { AddCells(row, summary => summary.AllocatedBytes, UnitType.Size, benchmarks); } } Console.WriteLine("```md"); // Format as a GitHub-flavored Markdown table table.Render(Console.Out); Console.WriteLine("```"); void AddCells( List <Cell> row, Func <BenchmarkSummary, object> valueFactory, UnitType unitType, List <BenchmarkSummary> summaries) { var rawValues = summaries .Select(summary => valueFactory(summary)) .Select(value => Convert.ToDouble(value)) .ToArray(); var precision = PrecisionHelper.GetPrecision(rawValues); var sizeUnit = unitType == UnitType.Size ? SizeUnit.GetBestSizeUnit(rawValues) : null; var timeUnit = unitType == UnitType.Time ? TimeUnit.GetBestTimeUnit(rawValues) : null; var units = unitType switch { UnitType.Size => sizeUnit.Name, UnitType.Time => timeUnit.Name, _ => string.Empty }; var baseline = summaries[0]; for (var i = 0; i < summaries.Count; i++) { var measure = rawValues[i]; var previous = rawValues[0]; var ratio = measure == 0 ? 0 : measure / previous; var formattedValue = unitType switch { UnitType.Size => new SizeValue((long)measure).ToString(sizeUnit), UnitType.Time => new TimeInterval(measure).ToString(timeUnit, precision), _ => measure.ToString("N" + precision, CultureInfo.InvariantCulture) }; var cell = new Cell(); cell.Elements.Add(new CellElement { Text = $"{formattedValue} {units}", Alignment = CellTextAlignment.Right }); row.Add(cell); // Don't render the ratio on baseline benchmark if (summaries[i] != baseline) { row.Add(cell = new Cell()); if (measure != 0) { cell.Elements.Add(new CellElement { Text = ratio.ToString("N2", CultureInfo.InvariantCulture), Alignment = CellTextAlignment.Right }); } } } } }
protected bool ShouldSerializeSizeUnit() { return(!SizeUnit.Equals(GetDefaultPropertyValue("SizeUnit", SizeUnit))); }
public static double Convert(long value, SizeUnit from, SizeUnit to) => value * (double)from.ByteAmount / (to ?? GetBestSizeUnit(value)).ByteAmount;