Пример #1
0
        internal static List <ChecksumType> GetChecksums(byte[] data, EnableChecksum enabled = EnableChecksum.All)
        {
            IChecksum adler32CtxData = null;
            IChecksum crc16CtxData   = null;
            IChecksum crc32CtxData   = null;
            IChecksum crc64CtxData   = null;
            IChecksum md5CtxData     = null;

            #if !NETSTANDARD2_0
            IChecksum ripemd160CtxData = null;
            #endif
            IChecksum sha1CtxData   = null;
            IChecksum sha256CtxData = null;
            IChecksum sha384CtxData = null;
            IChecksum sha512CtxData = null;
            IChecksum ssctxData     = null;
            IChecksum f16CtxData    = null;
            IChecksum f32CtxData    = null;

            Thread adlerThreadData = new Thread(UpdateHash);
            Thread crc16ThreadData = new Thread(UpdateHash);
            Thread crc32ThreadData = new Thread(UpdateHash);
            Thread crc64ThreadData = new Thread(UpdateHash);
            Thread md5ThreadData   = new Thread(UpdateHash);
            #if !NETSTANDARD2_0
            Thread ripemd160ThreadData = new Thread(UpdateHash);
            #endif
            Thread sha1ThreadData    = new Thread(UpdateHash);
            Thread sha256ThreadData  = new Thread(UpdateHash);
            Thread sha384ThreadData  = new Thread(UpdateHash);
            Thread sha512ThreadData  = new Thread(UpdateHash);
            Thread spamsumThreadData = new Thread(UpdateHash);
            Thread f16ThreadData     = new Thread(UpdateHash);
            Thread f32ThreadData     = new Thread(UpdateHash);

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                adler32CtxData = new Adler32Context();
                HashPacket adlerPktData = new HashPacket {
                    Context = adler32CtxData, Data = data
                };
                adlerThreadData.Start(adlerPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                crc16CtxData = new Crc16Context();
                HashPacket crc16PktData = new HashPacket {
                    Context = crc16CtxData, Data = data
                };
                crc16ThreadData.Start(crc16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                crc32CtxData = new Crc32Context();
                HashPacket crc32PktData = new HashPacket {
                    Context = crc32CtxData, Data = data
                };
                crc32ThreadData.Start(crc32PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                crc64CtxData = new Crc64Context();
                HashPacket crc64PktData = new HashPacket {
                    Context = crc64CtxData, Data = data
                };
                crc64ThreadData.Start(crc64PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                md5CtxData = new Md5Context();
                HashPacket md5PktData = new HashPacket {
                    Context = md5CtxData, Data = data
                };
                md5ThreadData.Start(md5PktData);
            }

            #if !NETSTANDARD2_0
            if (enabled.HasFlag(EnableChecksum.Ripemd160))
            {
                ripemd160CtxData = new Ripemd160Context();
                HashPacket ripemd160PktData = new HashPacket {
                    Context = ripemd160CtxData, Data = data
                };
                ripemd160ThreadData.Start(ripemd160PktData);
            }
            #endif

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                sha1CtxData = new Sha1Context();
                HashPacket sha1PktData = new HashPacket {
                    Context = sha1CtxData, Data = data
                };
                sha1ThreadData.Start(sha1PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                sha256CtxData = new Sha256Context();
                HashPacket sha256PktData = new HashPacket {
                    Context = sha256CtxData, Data = data
                };
                sha256ThreadData.Start(sha256PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                sha384CtxData = new Sha384Context();
                HashPacket sha384PktData = new HashPacket {
                    Context = sha384CtxData, Data = data
                };
                sha384ThreadData.Start(sha384PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                sha512CtxData = new Sha512Context();
                HashPacket sha512PktData = new HashPacket {
                    Context = sha512CtxData, Data = data
                };
                sha512ThreadData.Start(sha512PktData);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                ssctxData = new SpamSumContext();
                HashPacket spamsumPktData = new HashPacket {
                    Context = ssctxData, Data = data
                };
                spamsumThreadData.Start(spamsumPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                f16CtxData = new Fletcher16Context();
                HashPacket f16PktData = new HashPacket {
                    Context = f16CtxData, Data = data
                };
                f16ThreadData.Start(f16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                f32CtxData = new Fletcher32Context();
                HashPacket f32PktData = new HashPacket {
                    Context = f32CtxData, Data = data
                };
                f32ThreadData.Start(f32PktData);
            }

            while (adlerThreadData.IsAlive || crc16ThreadData.IsAlive || crc32ThreadData.IsAlive ||
                   crc64ThreadData.IsAlive || md5ThreadData.IsAlive ||
                  #if !NETSTANDARD2_0
                   ripemd160ThreadData.IsAlive ||
                  #endif
                   sha1ThreadData.IsAlive || sha256ThreadData.IsAlive || sha384ThreadData.IsAlive ||
                   sha512ThreadData.IsAlive || spamsumThreadData.IsAlive || f16ThreadData.IsAlive ||
                   f32ThreadData.IsAlive)
            {
            }

            List <ChecksumType> dataChecksums = new List <ChecksumType>();
            ChecksumType        chk;

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.adler32, Value = adler32CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.crc16, Value = crc16CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.crc32, Value = crc32CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.crc64, Value = crc64CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.md5, Value = md5CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            #if !NETSTANDARD2_0
            if (enabled.HasFlag(EnableChecksum.Ripemd160))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.ripemd160, Value = ripemd160CtxData.End()
                };
                dataChecksums.Add(chk);
            }
            #endif

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha1, Value = sha1CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha256, Value = sha256CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha384, Value = sha384CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.sha512, Value = sha512CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.spamsum, Value = ssctxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.fletcher16, Value = f16CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                chk = new ChecksumType {
                    type = ChecksumTypeType.fletcher32, Value = f32CtxData.End()
                };
                dataChecksums.Add(chk);
            }

            return(dataChecksums);
        }
Пример #2
0
        internal static List <ChecksumType> GetChecksums(byte[] data, EnableChecksum enabled = EnableChecksum.All)
        {
            IChecksum adler32CtxData = null;
            IChecksum crc16CtxData   = null;
            IChecksum crc32CtxData   = null;
            IChecksum crc64CtxData   = null;
            IChecksum md5CtxData     = null;
            IChecksum sha1CtxData    = null;
            IChecksum sha256CtxData  = null;
            IChecksum sha384CtxData  = null;
            IChecksum sha512CtxData  = null;
            IChecksum ssctxData      = null;
            IChecksum f16CtxData     = null;
            IChecksum f32CtxData     = null;

            var adlerThreadData   = new Thread(UpdateHash);
            var crc16ThreadData   = new Thread(UpdateHash);
            var crc32ThreadData   = new Thread(UpdateHash);
            var crc64ThreadData   = new Thread(UpdateHash);
            var md5ThreadData     = new Thread(UpdateHash);
            var sha1ThreadData    = new Thread(UpdateHash);
            var sha256ThreadData  = new Thread(UpdateHash);
            var sha384ThreadData  = new Thread(UpdateHash);
            var sha512ThreadData  = new Thread(UpdateHash);
            var spamsumThreadData = new Thread(UpdateHash);
            var f16ThreadData     = new Thread(UpdateHash);
            var f32ThreadData     = new Thread(UpdateHash);

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                adler32CtxData = new Adler32Context();

                var adlerPktData = new HashPacket
                {
                    Context = adler32CtxData,
                    Data    = data
                };

                adlerThreadData.Start(adlerPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                crc16CtxData = new CRC16IBMContext();

                var crc16PktData = new HashPacket
                {
                    Context = crc16CtxData,
                    Data    = data
                };

                crc16ThreadData.Start(crc16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                crc32CtxData = new Crc32Context();

                var crc32PktData = new HashPacket
                {
                    Context = crc32CtxData,
                    Data    = data
                };

                crc32ThreadData.Start(crc32PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                crc64CtxData = new Crc64Context();

                var crc64PktData = new HashPacket
                {
                    Context = crc64CtxData,
                    Data    = data
                };

                crc64ThreadData.Start(crc64PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                md5CtxData = new Md5Context();

                var md5PktData = new HashPacket
                {
                    Context = md5CtxData,
                    Data    = data
                };

                md5ThreadData.Start(md5PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                sha1CtxData = new Sha1Context();

                var sha1PktData = new HashPacket
                {
                    Context = sha1CtxData,
                    Data    = data
                };

                sha1ThreadData.Start(sha1PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                sha256CtxData = new Sha256Context();

                var sha256PktData = new HashPacket
                {
                    Context = sha256CtxData,
                    Data    = data
                };

                sha256ThreadData.Start(sha256PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                sha384CtxData = new Sha384Context();

                var sha384PktData = new HashPacket
                {
                    Context = sha384CtxData,
                    Data    = data
                };

                sha384ThreadData.Start(sha384PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                sha512CtxData = new Sha512Context();

                var sha512PktData = new HashPacket
                {
                    Context = sha512CtxData,
                    Data    = data
                };

                sha512ThreadData.Start(sha512PktData);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                ssctxData = new SpamSumContext();

                var spamsumPktData = new HashPacket
                {
                    Context = ssctxData,
                    Data    = data
                };

                spamsumThreadData.Start(spamsumPktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                f16CtxData = new Fletcher16Context();

                var f16PktData = new HashPacket
                {
                    Context = f16CtxData,
                    Data    = data
                };

                f16ThreadData.Start(f16PktData);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                f32CtxData = new Fletcher32Context();

                var f32PktData = new HashPacket
                {
                    Context = f32CtxData,
                    Data    = data
                };

                f32ThreadData.Start(f32PktData);
            }

            while (adlerThreadData.IsAlive ||
                   crc16ThreadData.IsAlive ||
                   crc32ThreadData.IsAlive ||
                   crc64ThreadData.IsAlive ||
                   md5ThreadData.IsAlive ||
                   sha1ThreadData.IsAlive ||
                   sha256ThreadData.IsAlive ||
                   sha384ThreadData.IsAlive ||
                   sha512ThreadData.IsAlive ||
                   spamsumThreadData.IsAlive ||
                   f16ThreadData.IsAlive ||
                   f32ThreadData.IsAlive)
            {
            }

            List <ChecksumType> dataChecksums = new List <ChecksumType>();
            ChecksumType        chk;

            if (enabled.HasFlag(EnableChecksum.Adler32))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.adler32,
                    Value = adler32CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc16))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.crc16,
                    Value = crc16CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc32))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.crc32,
                    Value = crc32CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Crc64))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.crc64,
                    Value = crc64CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Md5))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.md5,
                    Value = md5CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha1))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha1,
                    Value = sha1CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha256))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha256,
                    Value = sha256CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha384))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha384,
                    Value = sha384CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Sha512))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.sha512,
                    Value = sha512CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.SpamSum))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.spamsum,
                    Value = ssctxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher16))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.fletcher16,
                    Value = f16CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            if (enabled.HasFlag(EnableChecksum.Fletcher32))
            {
                chk = new ChecksumType
                {
                    type  = ChecksumTypeType.fletcher32,
                    Value = f32CtxData.End()
                };

                dataChecksums.Add(chk);
            }

            return(dataChecksums);
        }
Пример #3
0
        public static BenchmarkResults Do(int bufferSize, int blockSize)
        {
            BenchmarkResults results = new BenchmarkResults
            {
                Entries      = new Dictionary <string, BenchmarkEntry>(),
                MinMemory    = long.MaxValue,
                MaxMemory    = 0,
                SeparateTime = 0
            };
            MemoryStream ms  = new MemoryStream(bufferSize);
            Random       rnd = new Random();
            DateTime     start;
            DateTime     end;

            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Writing block {0} of {1} with random data.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                rnd.NextBytes(tmp);
                ms.Write(tmp, 0, blockSize);
            }

            EndProgress();
            end = DateTime.Now;

            results.FillTime  = (end - start).TotalSeconds;
            results.FillSpeed = bufferSize / 1048576.0 / (end - start).TotalSeconds;

            ms.Seek(0, SeekOrigin.Begin);
            long mem = GC.GetTotalMemory(false);

            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Reading block {0} of {1}.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
            }

            EndProgress();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.ReadTime  = (end - start).TotalSeconds;
            results.ReadSpeed = bufferSize / 1048576.0 / (end - start).TotalSeconds;

            #region Adler32
            IChecksum ctx = new Adler32Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with Adler32.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("Adler32",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion Adler32

            #region Fletcher16
            ctx = new Fletcher16Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with Fletcher-16.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("Fletcher16",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion Fletcher16

            #region Fletcher32
            ctx = new Fletcher32Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with Fletcher-32.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("Fletcher32",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion Fletcher32

            #region CRC16
            ctx = new Crc16Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with CRC16.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("CRC16",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion CRC16

            #region CRC32
            ctx = new Crc32Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with CRC32.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("CRC32",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion CRC32

            #region CRC64
            ctx = new Crc64Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with CRC64.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("CRC64",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion CRC64

            #region MD5
            ctx = new Md5Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with MD5.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("MD5",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion MD5

            #if !NETSTANDARD2_0
            #region RIPEMD160
            ctx = new Ripemd160Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with RIPEMD160.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("RIPEMD160",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion RIPEMD160
            #endif

            #region SHA1
            ctx = new Sha1Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with SHA1.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("SHA1",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion SHA1

            #region SHA256
            ctx = new Sha256Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with SHA256.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("SHA256",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion SHA256

            #region SHA384
            ctx = new Sha384Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with SHA384.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("SHA384",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion SHA384

            #region SHA512
            ctx = new Sha512Context();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with SHA512.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("SHA512",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion SHA512

            #region SpamSum
            ctx = new SpamSumContext();
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Checksumming block {0} of {1} with SpamSum.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                ctx.Update(tmp);
            }

            EndProgress();
            ctx.End();
            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.Entries.Add("SpamSum",
                                new BenchmarkEntry
            {
                TimeSpan = (end - start).TotalSeconds,
                Speed    = bufferSize / 1048576.0 / (end - start).TotalSeconds
            });
            results.SeparateTime += (end - start).TotalSeconds;
            #endregion SpamSum

            #region Entropy
            ulong[] entTable = new ulong[256];
            ms.Seek(0, SeekOrigin.Begin);
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }
            start = DateTime.Now;
            InitProgress();
            for (int i = 0; i < bufferSize / blockSize; i++)
            {
                UpdateProgress("Entropying block {0} of {1}.", i + 1, bufferSize / blockSize);
                byte[] tmp = new byte[blockSize];
                ms.Read(tmp, 0, blockSize);
                foreach (byte b in tmp)
                {
                    entTable[b]++;
                }
            }

            EndProgress();

            end = DateTime.Now;
            mem = GC.GetTotalMemory(false);
            if (mem > results.MaxMemory)
            {
                results.MaxMemory = mem;
            }
            if (mem < results.MinMemory)
            {
                results.MinMemory = mem;
            }

            results.EntropyTime  = (end - start).TotalSeconds;
            results.EntropySpeed = bufferSize / 1048576.0 / (end - start).TotalSeconds;
            #endregion Entropy

            /*
             #region Multitasking
             * start                 = DateTime.Now;
             * Checksum allChecksums = new Checksum();
             * InitProgress();
             * for(int i = 0; i < bufferSize / blockSize; i++)
             * {
             *  UpdateProgress("Checksumming block {0} of {1} with all algorithms at the same time.", i + 1,
             *                 bufferSize / blockSize);
             *  byte[] tmp = new byte[blockSize];
             *  ms.Read(tmp, 0, blockSize);
             *
             *  allChecksums.Update(tmp);
             * }
             *
             * EndProgress();
             *
             * allChecksums.End();
             * end                                           = DateTime.Now;
             * mem                                           = GC.GetTotalMemory(false);
             * if(mem > results.MaxMemory) results.MaxMemory = mem;
             * if(mem < results.MinMemory) results.MinMemory = mem;
             *
             * results.TotalTime  = (end - start).TotalSeconds;
             * results.TotalSpeed = bufferSize / 1048576.0 / results.TotalTime;
             #endregion
             */
            results.SeparateSpeed = bufferSize / 1048576.0 / results.SeparateTime;

            return(results);
        }