[C#] CRC32 berekenen erg traag

[Tanuki]

Ik gebruik onderstaande class om de CRC van een bestand uit te rekenen.

C#:

    public delegate void CalculationProgressHandler(int progress);

    public class Crc32
    {
        // Events
        public event CalculationProgressHandler CalculationProgress;

        // Data
        private static readonly uint[] lookUp = new uint[]
        {
            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
            0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
            0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
            0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
            0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
            0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
            0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
            0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
            0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
            0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
            0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
            0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
            0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
            0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
            0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
            0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,

            0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
            0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
            0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
            0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
            0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
            0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
            0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
            0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
            0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
            0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
            0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
            0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
            0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
            0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
            0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
            0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,

            0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
            0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
            0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
            0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
            0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
            0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
            0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
            0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
            0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
            0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
            0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
            0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
            0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
            0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
            0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
            0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,

            0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
            0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
            0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
            0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
            0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
            0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
            0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
            0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
            0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
            0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
            0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
            0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
            0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
            0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
            0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
            0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
        };
        private static readonly int poly = 0xFFFFFF;
        
        // Constructors
        public Crc32()
        {

        }

        // Methods
        public long CalculateCrc(FileInfo file)
        {
            long crc = poly;
            int progress = 0;

            FileStream stream = file.OpenRead();
            BufferedStream bufferedStream = new BufferedStream(stream);

            for (long i = 0; i < bufferedStream.Length; i++)
            {
                byte b = Convert.ToByte(bufferedStream.ReadByte());
                crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ b];

                int progressNew = (int)Math.Round((double)100 / bufferedStream.Length * i);
                if (progress != progressNew)
                {
                    progress = progressNew;
                    this.OnCalculationProgress(progress);
                }
            }

            bufferedStream.Close();
            stream.Close();

            return crc;
        }

        // Event handlers
        private void OnCalculationProgress(int progress)
        {
            if (this.CalculationProgress != null)
            {
                this.CalculationProgress(progress);
            }
        }
    }

Dat doe ik op de volgende manier (binnen een andere class):

C#:

                Crc32 crc = new Crc32();
                crc.CalculationProgress += delegate(int progress)
                {
                    this.OnCrcCalculationProgress(progress);
                };
                long calculatedCrc = crc.CalculateCrc(file);

Het CrcCalculationProgress event wordt opgevangen in de GUI, waar ik een progressbar steeds instel met de waarde uit progress.

Het doorlopen van de files en het uitrekenen van de Crc's (en nog wat andere zaken zoals het toevoegen in de database) gebeurt binnen een backgroundworker. Ik weet niet of dat verder relevant is.

Nu is het zo dat alles wel werkt, maar het is erg, heel erg, traag. In mijn applicatie zie ik de progressbar heel langzaam bewegen en het duurt voor een file van 15 MB ongeveer 40 seconden. Als ik met hkSFV een .sfv bestand (is ook crc32) maak dan duurt het nog geen halve seconde.
Ook als ik

C#:

                crc.CalculationProgress += delegate(int progress)
                {
                    this.OnCrcCalculationProgress(progress);
                };

weghaal duurt het nog steeds ruim 40 seconden.

Nou moet ik wel eerlijk toegeven dat ik verder weinig verstand heb van crc rekenen (ooit eens met Cisco gehad, maarja ). Maar voor zover ik zie is de code redelijk netjes en duidelijk, ik doe geen rare dingen zoals onnodige loops of zo.

Is C# gewoon geen taal waar je dit soort dingen snel en efficient kan doen? Of is mijn code 99% van de tijd onnodige dingen aan het doen en zie ik dat op dit moment niet?

[Tanuki]

Mja ik snap dus ook wel dat die for-loop 15 miljoen keer wordt doorlopen, maar... Is er een andere manier?
Hij zal toch steeds die waardes moeten checken neem ik aan.

[Sebazzz]

Volgens http://www.daniweb.com/forums/thread48980.html is het het beste om een C lib te nemen zoals http://www.codeguru.com/c...ecksum/article.php/c5103/ en dat te gebruiken als methode. Maar een andere oplossing kan dit zijn: http://www.codeproject.com/KB/cs/marcelcrcencoding.aspx

[ Voor 14% gewijzigd door Sebazzz op 20-12-2008 22:52 ]

[user109731]

Ik zou niet bij elke byte de progress updaten. Dat scheelt misschien al iets. Je kunt ook nog proberen Convert.ToByte(x) te vervangen door (byte)x. ToByte voert wat extra checks uit.

Verder is het een kwestie van profilen? Je zegt 40 seconden, het moet uit te zoeken zijn waar dat in zit. Dat kan eenvoudig door statements 'uit te zetten', zelf met DateTime uitrekenen of rigoreuzer met een profiler

[ Voor 54% gewijzigd door user109731 op 20-12-2008 23:11 ]

[DaCoTa]

en zo:

code:

            for (long i = 0; i < bufferedStream.Length; i++)
            {
                crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ Convert.ToByte(bufferedStream.ReadByte())];
            }

Plus dat je mss een andere stream moet nemen, eentje die zonder die convert werkt.

[ Voor 16% gewijzigd door DaCoTa op 20-12-2008 22:54 ]

[CoolGamer]

Als je i.p.v. ReadByte Read gebruikt van een BufferedStream en steeds een hele array van bijvoorbeeld 256 elementen inleest gaat het veel sneller.

Bijvoorbeeld zoiets:

C#:

public long CalculateCrc(FileInfo file)
        {
            long crc = poly;
            int progress = 0;

            FileStream stream = file.OpenRead();
            BufferedStream bufferedStream = new BufferedStream(stream);

            byte[] buffer = new byte[512];
            int bytesRead;

            for (int i = 0; i < bufferedStream.Length; i+=bytesRead)
            {
                bytesRead = bufferedStream.Read(buffer, 0, buffer.Length);
                for (int j = 0; j < bytesRead; j++)
                {
                    crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ buffer[j]];
                }

                int progressNew = (int)Math.Round((double)100 / bufferedStream.Length * i); 
                if (progress != progressNew)
                {
                    progress = progressNew;
                    this.OnCalculationProgress(progress);
                }
            }

            bufferedStream.Close();
            stream.Close();

            return crc;
        }

Zo hoef je niet de hele loop te doorlopen (dus ook niet steeds te controleren op progress), maar slechts 1 regel te loopen. Ook is Read efficiënter dan ReadByte.

[ Voor 6% gewijzigd door CoolGamer op 20-12-2008 23:26 . Reden: Uitleg iets uitgebreid ]

[MrBucket]

JanDM schreef op zaterdag 20 december 2008 @ 22:51:
... of rigoreuzer met een profiler

Sommige versies van Visual Studio Team System bevatten een profiler (ik weet zo gauw even niet welke versies). Mocht je een versie zonder profiler hebben, dan is NProf misschien een goede uitkomst - ik heb er goede ervaringen mee, in ieder geval.

(Let erop dat je bij het downloaden expliciet kiest voor de laatste versie: 0.9)

[Tanuki]

TheCoolGamer schreef op zaterdag 20 december 2008 @ 23:21:
Als je i.p.v. ReadByte Read gebruikt van een BufferedStream en steeds een hele array van bijvoorbeeld 256 elementen inleest gaat het veel sneller.

Bijvoorbeeld zoiets:

C#:

public long CalculateCrc(FileInfo file)
        {
            long crc = poly;
            int progress = 0;

            FileStream stream = file.OpenRead();
            BufferedStream bufferedStream = new BufferedStream(stream);

            byte[] buffer = new byte[512];
            int bytesRead;

            for (int i = 0; i < bufferedStream.Length; i+=bytesRead)
            {
                bytesRead = bufferedStream.Read(buffer, 0, buffer.Length);
                for (int j = 0; j < bytesRead; j++)
                {
                    crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ buffer[j]];
                }

                int progressNew = (int)Math.Round((double)100 / bufferedStream.Length * i); 
                if (progress != progressNew)
                {
                    progress = progressNew;
                    this.OnCalculationProgress(progress);
                }
            }

            bufferedStream.Close();
            stream.Close();

            return crc;
        }

Zo hoef je niet de hele loop te doorlopen (dus ook niet steeds te controleren op progress), maar slechts 1 regel te loopen. Ook is Read efficiënter dan ReadByte.

Hier heb ik inderdaad wat aan gehad. Bedankt.

Een profiler lijkt me wel iets dat ik moet hebben.. Ga ik ook eens naar kijken. Altijd interessant om te zien waar de bottleneck in je code ligt en zo.

[Snake]

MrBucket schreef op zondag 21 december 2008 @ 12:00:
[...]



Sommige versies van Visual Studio Team System bevatten een profiler (ik weet zo gauw even niet welke versies). Mocht je een versie zonder profiler hebben, dan is NProf misschien een goede uitkomst - ik heb er goede ervaringen mee, in ieder geval.

(Let erop dat je bij het downloaden expliciet kiest voor de laatste versie: 0.9)

Team System altijd. De Professional niet

[farlane]

Mijn gevoel zegt dat van de bewerkingen die je doet de UI update voor de meeste vertraging zorgt.

[Tanuki]

farlane schreef op dinsdag 23 december 2008 @ 14:29:
Mijn gevoel zegt dat van de bewerkingen die je doet de UI update voor de meeste vertraging zorgt.

Neehee. Ik trigger maar 100 keer per file een event (daar was die if voor in bovenstaande code).

Ik heb het nu zo gemaakt dat die buffer filesize/100 is, dus ik krijg 100x het CalculationProgress event (die if van hierboven is nu ook weg dus).
Moet nog wel even bedenken wat ik ga doen met asociaal grote bestanden. Alhoewel, 700 MB / 100 is 7 MB, valt ook nog best mee.

[farlane]

l0c4lh0st schreef op woensdag 24 december 2008 @ 02:45:
Neehee. Ik trigger maar 100 keer per file een event (daar was die if voor in bovenstaande code).

Ik heb het nu zo gemaakt dat die buffer filesize/100 is, dus ik krijg 100x het CalculationProgress event (die if van hierboven is nu ook weg dus).
Moet nog wel even bedenken wat ik ga doen met asociaal grote bestanden. Alhoewel, 700 MB / 100 is 7 MB, valt ook nog best mee.

Lijkt me een perfecte oplossing, zeker als je een DVD iso moet gaan checksummen.

Wat ik me wel heel erg afvraag is wat het nut is van een Bufferedstream als het ding blijkbaar niet buffered en alsnog zelf een buffering eromheen moet bouwen. Weet je zeker dat je het ding goed gebruikt?

[Marcj]

Het berekenen van progressNew lijkt hier ook een redelijk zware operatie, vooral met een Math.Round erin. Is het niet slimmer om van tevoren te berekenen wat 1/100ste deel van de totale lengte is en om het totaal aantal bytes daartegen te controleren? Dan krijg je zoiets:

Bijvoorbeeld zoiets:

C#:

        public long CalculateCrc(FileInfo file)
        {
            long crc = poly;
            int progress = 0;

            FileStream stream = file.OpenRead();
            int length = stream.Length;
            int stepIncr = length / 100;
            int nextStep = stepIncr;

            byte[] buffer = new byte[1024];
            int bytesRead;
            int ix = 0;
            while(ix < length)
            {
                bytesRead = stream.Read(buffer, 0, buffer.Length);
                for (int j = 0; j < bytesRead; j++)
                {
                    crc = (crc >> 8) ^ lookUp[(crc & 0xFF) ^ buffer[j]];
                }

                ix += bytesRead;
                while(ix >= nextStep) {
                    progress++;
                    OnCalculationProgress(progress);
                    nextStep += stepIncr;
                }
            }

            bufferedStream.Close();
            stream.Close();

            return crc;
        }

_{Disclaimer: niet getest of zelfs in visual studio geprobeert}

[CoolGamer]

Marcj schreef op woensdag 24 december 2008 @ 11:23:

C#:

            [..]
            FileStream stream = file.OpenRead();
            int length = stream.Length;
            int stepIncr = length / 100;
            int nextStep = stepIncr;
            [..]
                ix += bytesRead;
                while(ix >= nextStep) {
                    progress++;
                    OnCalculationProgress(progress);
                    nextStep += stepIncr;
                }
            [..]

Wat nou als length kleiner is dan 100, dan wordt stepIncr 0 en nextStep ook 0. Dan in de while-loop is ix altijd groter dan nextStep en krijg je een oneindige loop.

Maar hier zat de grootste bottleneck niet (dit zat namelijk in het gebruik van ReadByte) en zal niet significant veel schelen als je dit aanpast.

[ Voor 0% gewijzigd door CoolGamer op 24-12-2008 15:44 . Reden: typo ]

[Tanuki]

farlane schreef op woensdag 24 december 2008 @ 09:59:
[...]


Lijkt me een perfecte oplossing, zeker als je een DVD iso moet gaan checksummen.

Wat ik me wel heel erg afvraag is wat het nut is van een Bufferedstream als het ding blijkbaar niet buffered en alsnog zelf een buffering eromheen moet bouwen. Weet je zeker dat je het ding goed gebruikt?

Die bufferedstream was wel leuk, maar die kon ik hier niet echt goed gebruiken. Dus die is er uit.

Uiteindelijke code is:

C#:

namespace NietBoeiendOfZo
{
    public delegate void CalculationProgressHandler(int progress);

    public class Crc32
    {
        // Events
        public event CalculationProgressHandler CalculationProgress;

        // Constructors
        public Crc32()
        {

        }

        // Methods
        public long CalculateCrc(FileInfo file)
        {
            long crc = Polynomal;
            int bytesRead;

            FileStream stream = file.OpenRead();
            byte[] buffer = new byte[(int)Math.Ceiling((double)file.Length / 100)];
            for (int i = 0; i < stream.Length; i += bytesRead)
            {
                bytesRead = stream.Read(buffer, 0, buffer.Length);
                for (int j = 0; j < bytesRead; j++)
                {
                    crc = (crc >> 8) ^ LookUp[(crc & 0xFF) ^ buffer[j]];
                }
                this.OnCalculationProgress((int)Math.Floor(((100 / (double)stream.Length) * (i + bytesRead))));
            }
            stream.Close();

            crc ^= Polynomal;

            return crc;
        }

        // Event handlers
        private void OnCalculationProgress(int progress)
        {
            if (this.CalculationProgress != null)
            {
                this.CalculationProgress(progress);
            }
        }

        // Data
        public static readonly uint Polynomal = 0xFFFFFFFF;
        public static readonly uint[] LookUp = new uint[256]
        {
            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
            0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
            0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
            0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
            0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
            0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
            0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
            0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
            0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
            0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
            0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
            0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
            0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
            0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
            0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
            0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
            0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
            0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
            0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
            0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
            0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
            0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
            0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
            0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
            0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
            0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
            0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
            0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
            0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
            0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
            0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
            0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
            0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
            0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
            0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
            0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
            0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
            0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
            0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
            0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
            0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
            0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
            0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
            0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
            0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
            0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
            0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
            0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
            0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
            0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
            0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
            0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
            0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
            0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
            0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
            0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
            0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
            0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
            0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
            0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
            0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
            0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
            0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
            0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D 
        };
    }
}

Er zit dus nog geen check in bij "te grote" bestanden. Als ik er nu een file van 45 GB naar toe gooi gaat ie vrolijk een buffer van 450 MB maken. Maar dat komt op de todo, hij werkt nu voor de bestanden waarvoor ik wil dat ie werkt.