dev-npgsql/npgsql: Npgsql is the .NET data provider for PostgreSQL.

test/Npgsql.Benchmarks/Numeric.cs
101 строка3 KB
Yoh Deadfall
Added benchmark for numeric handler
29 май 2018, 12:16
29 май 2018, 12:1658367c7
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Columns;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Diagnosers;
using Npgsql.TypeHandlers.NumericHandlers;
using System;
using System.IO;
using System.Text;

namespace Npgsql.Benchmarks
{
    [Config(typeof(Config))]
    public class Numeric
    {
        class Config : ManualConfig
        {
            public Config()
            {
                Add(StatisticColumn.OperationsPerSecond);
                Add(MemoryDiagnoser.Default);
            }
        }

        class EndlessStream : Stream
        {
            public override bool CanRead => true;
            public override bool CanSeek => true;
            public override bool CanWrite => true;
            public override long Length => long.MaxValue;
            public override long Position { get => 0L; set { } }
            public override void Flush() { }
            public override int Read(byte[] buffer, int offset, int count) => count;
            public override long Seek(long offset, SeekOrigin origin) => 0L;
            public override void SetLength(long value) { }
            public override void Write(byte[] buffer, int offset, int count) { }
        }

        readonly EndlessStream _stream = new EndlessStream();
        readonly NumericHandler _handler = new NumericHandler();
        readonly NpgsqlReadBuffer _readBuffer;
        readonly NpgsqlWriteBuffer _writeBuffer;
        decimal _value;
        int _elementSize;

        public Numeric()
        {
            _stream = new EndlessStream(); _handler = new NumericHandler();
            _readBuffer = new NpgsqlReadBuffer(null, _stream, NpgsqlReadBuffer.MinimumSize, Encoding.UTF8);
            _writeBuffer = new NpgsqlWriteBuffer(null, _stream, NpgsqlWriteBuffer.MinimumSize, Encoding.UTF8);
        }

        public decimal Value
        {
            get => _value;
            set
            {
                _value = value;
                _elementSize = _handler.ValidateAndGetLength(value, null);
                _handler.Write(_value, _writeBuffer, null);

                Buffer.BlockCopy(_writeBuffer.Buffer, 0, _readBuffer.Buffer, 0, _elementSize);

                _readBuffer.FilledBytes = _elementSize;
                _writeBuffer.WritePosition = 0;
            }
        }

        public static decimal[] Values => new decimal[]
        {
            0.0000000000000000000000000001M,
            0.000000000000000000000001M,
            0.00000000000000000001M,
            0.0000000000000001M,
            0.000000000001M,
            0.00000001M,
            0.0001M,
            1M,
            10000M,
            100000000M,
            1000000000000M,
            10000000000000000M,
            100000000000000000000M,
            1000000000000000000000000M,
            10000000000000000000000000000M,
        };

        [Benchmark]
        public void Read()
        {
            _readBuffer.ReadPosition = 0;
            _handler.Read(_readBuffer, _elementSize);
        }

        [Benchmark]
        public void Write()
        {
            _writeBuffer.WritePosition = 0;
            _handler.Write(_value, _writeBuffer, null);
        }
    }
}