DataGhost schreef op woensdag 22 december 2010 @ 22:06:
Maar je kan met 1 commando tot 32MB (nouja, 64Ki sectors dus met deze schijven 256MB als de controller het ondersteunt) ophalen... waar blijft die queue van je dan precies? Denk je serieus dat voor elke sector een apart commando wordt gegeven? Behalve TFTP ken ik eigenlijk geen dataoverdrachtsprotocol dat nog zo werkt.
Nee dat klopt, maar om het simpel te houden; het is al ingewikkeld genoeg.
Request sizes zijn doorgaans gelimiteerd tot 128KiB. Dus als je een 32 kilobyte bestand inleest is de request size ook 32KiB; één I/O request voor de hele file. Als een file heel groot is (zeg 1GB; maar eigenlijk alles boven de 128KiB) zullen er meerdere requests worden gestuurd; meestal zijn die 128KiB groot. Echter Windows 7 net als sommige OSen heeft nu de mogelijkheid grotere requests te gebruiken; echt nuttig is dit niet 128KiB werkt al vrij efficient.
Oke dus als je 1GB bestand inleest, dan gebruikt je filesystem blokken van 128KiB om dat in te lezen. Waar blijft de queue depth dan precies? Nou simpelweg door meerdere requests
tegelijkertijd te sturen. Dus 8 requests van elk 128KiB betekent dus 1 megabyte read-ahead, terwijl je requests 128KiB groot zijn.
Terug naar HDtune: die doet tot 1 megabyte requests, maar altijd met queue depth =1, je zult dus heel grote request size moeten gebruiken om een 'normale' queue depth te simuleren: 1 megabyte blocksize komt overeen met 128KiB request size met queue depth = 8.
Wat Queue Depth doet met I/O performance, doet TCP Receive Window met netwerk performance; die twee technieken zijn vrijwel identiek. Als je TCP Receive Window begrijpt, dan begrijp je Queue Depth veel makkelijker. Hier is een prachtig voorbeeld wat laat zien hoe hardware zonder werk komt te zitten en hoe queueing dit verhelpt, een animated GIF dus zeker kijken:
http://cable-dsl.navasgroup.com/rwinanim.htmDat bedoelde ik dus niet zo. Anyway, hoe verklaar je dan met 7200rpm * 512B4096B (vooruit dan) * 2schijven = 28.8 MB/min = 492 KiB/s een leessnelheid van ruim 100 MB/s?
Je hebt gelijk ik maak een fout met mn berekening.
7200rpm = 7200/60 = 120 toeren per seconde = 120 IOps als er voor elke I/O één rotatie nodig is, waar we voor het gemak even vanuit gaan. Als je 128KiB request size gebruikt kom je dan op snelheden van 128 * 120 = 15MiB/s. Ga je kleine bestanden lezen en houd je het op 4KiB request size, kom je nog niet verder dan 0.5MB/s en met 512-byte requests slechts een achtste daarvan.
Het hele idee van queue depth, read-ahead en write buffering is dat het mechanische gedeelte van de HDD bezig blijft: een hardeschijf is heel snel in het overpompen van data (sequential I/O) maar heel langzaam in het zoeken van data (access time). Dus ideaal gezien wil je alleen maar sequential I/O doen en de leeskop nooit op laten houden: dan lees/schrijf je tegen de hoogst mogelijke snelheid en dan zijn HDDs vrijwel even snel als SSDs.
Queue depth is ook
cruciaal om RAID0 te laten schalen. Voor een 2-disk RAID0 heb je minimaal twee I/O's op hetzelfde moment nodig om beide schijven aan een aparte I/O te laten werken, om aldus een 100% performance scaling te behalen. Met queue depth = 1 kun je maximaal 1 schijf tegelijkertijd aan het werk zetten in een striping RAID. Merk op dat hier veel uitzonderingen op zijn, maar geen van allen zijn echt belangrijk om te onthouden.
Aangezien jij stelt dat het filesystem juist de issue is? Dat zou, lijkt me, dan betekenen dat meer mensen er last van zouden hebben?
Het is jammer dat we elkaar nog niet begrijpen. Ik stel juist dat er helemaal geen probleem is: het filesystem levert hogere performance op RAID0 dan HDtune kan meten afhankelijk van de gebruikte RAID controller. Dus de enige 'issue' is dat HDtune te lage scores aangeeft en de daadwerkelijke performance hoger ligt. De Silicon Image FakeRAID drivers zijn nog steeds niet echt goed, maar de 'issue' hier is vooral dat TS vooral
denkt dat zijn performance heel laag is, omdat HDtune zijn type RAID engine niet goed kan testen. Goed in de zin van: het nabootsen van realistisch gebruik.
Dus even stel andere benchmarks geven 200MB/s aan en HDTune maar 100MB/s; wat is dan het probleem? Als je echt bestanden gaat inlezen/schrijven gaat dat met 200MB/s omdat ALLES via het filesystem gaat; behalve kunstmatige benchmarks zoals IOmeter, HDTune en HDTach. Als je ruwe I/O doet moet je goed weten wat je doet anders weet je niet meer wat de score die je krijgt precies inhoudt; wát ben je precies aan het testen als je HDTune draait op silicon image RAID? Welke vraag beantwoord die scores? Geen naar mijn mening.
Dus échte programma's hebben zelfgeschreven RAID-drivers aan boord? Of waar praten ze dan precies tegen?
Programma's weten natuurlijk niets van RAID; enige wat ze 'weten' zijn API-calls om het NTFS filesystem te gebruiken om bestanden te lezen/schrijven; en hebben daarbij de keuze tussen blocking I/O en non-blocking I/O; cruciaal voor schalen van RAID0 en houdt ook groot verband met queue depth; allemaal voor een andere dag.
Dus een programma vraagt aan meneer NTFS "ik wil die file lezen". NTFS kijkt naar de file, ziet dat hij lekker groot is en stuurt gelijk 8 requests van 128KiB naar de RAID driver, die vervolgens de requests verdeelt onder de RAID members. Doordat de RAID driver meerdere requests krijgt, komen de schijven niet zonder werk te zitten en kunnen ze tegelijkertijd werken en heeft RAID0 dus een snelheidsvoordeel.
De RAID members passen elk intern read-ahead toe, waardoor er dus dubbel read-ahead toegepast wordt: door het filesystem en de HDD/SSD zelf; dat is prima niks mis mee. In geval van een hardware RAID controller komt daar nóg een read-ahead mechanisme bij: de controller zelf. Dan krijg je dus wel hoge HDtune resultaten, maar de echte resultaten via het filesystem zullen vrijwel onveranderd blijven.
Omdat ik een vergelijking wil kunnen maken, onafhankelijk van factoren die weer kunnen veranderen, zoals bijvoorbeeld filesystems ja.
Oke dat is een geldig punt; je wilt zo 'low-level' mogelijk zitten zodat je elke keer consistente resultaten krijgt ongeacht fragmentatie en locatie van vrije ruimte op je filesystem. Als je een volume test dat 40% vol zit, test je niet meer de snelste gedeeltes van je hardeschijf; terwijl je met HDtune wel het begin en eind kan zien van je HDD en dus meer informatie hebt; oke als dat je punt is heb je hier wel een argument.
Maar als je dan HDtune gebruikt, zet dan de blocksize zo hoog mogelijk; dan simuleer je gewoon een hogere queue depth en krijg je wel een redelijk resultaat.
Okee.
Sorry als ik niet zo aardig klonk. Het punt is meer: deze materie is redelijk ingewikkeld en ik merkte dat je op sommige punten nog niet voldoende basiskennis hebt over hoe I/O werkt. Dat maakt het ietwat frustrerend om deze zeer theoretische zaken uit te leggen; sommige dingen leer je het beste door het zelf te doen, zelf te zien, zelf te ervaren.
Pas als je RAID0 door en door begrijpt, heb je een redelijk idee van I/O performance. Dan kun je meer verborgen dingen proberen te begrijpen, bijvoorbeeld waarom SSDs hetzelfde principe als RAID0 gebruiken en krijg je veel meer beoordelingsvermogen om een bepaalde benchmark op zijn waarde te schatten. Maar al te vaak worden er benchmarks gedraaid waarbij onduidelijk is wat de getallen voorstellen; ook bij reputabele reviewsites.
Als je dit nou interessant vindt: waarom ga je niet eens wat kloten met software RAID0 onder Linux of BSD? Uitstekend om dit allemaal te leren; zet een I/O monitor aan en kijk wat er gebeurt, waar gaat je I/O naartoe en hoe gedraagt een filesystem zich. Hoe verhoudt ruwe I/O zich tot buffered I/O (met hogere queue depth), etc.
Ik wil er best meer over schrijven; ik snap dat je nog veel vragen hebt. Maar misschien is het beter dat in een apart topic te doen? Dat laat ik aan jou over; mocht je daartoe besluiten dan zal ik ook de moeite nemen mijn vergaarde kennis met je te delen.