Festplattengeschwindigkeit messen

CyberTim

Also es geht um folgendes:

ich muss ein programm schreiben, mit dem ich die lese- und schreib-geschwindigkeit von Festplatte und Diskette schreiben testen soll. bei der Dateiausgabe habe ich bisher ein Prob. ein 10 MB-Datei dauert ne halbe ewigkeit (ne halbe stunde oder so). aber sonst tut es soweit. hier erstmal der code...

int write_hdd_file(int groesse)
{
   FILE *datei;
    int i;
    char *vector;

    vector = (char *) malloc (1024*groesse);        //dynamischen Vektor erzeugen
    if (vector == NULL)
   {
      free(vector);
    return(1);
   }

    for (i = 0; i<groesse; i++)
        {
            *(vector+i) = 1;
        }

    if ((datei = fopen("f:/test.txt","w+t"))==NULL)
    {
        free(vector);
        return(1);
    }

    fwrite(vector, sizeof(char),groesse*1024/sizeof(char),datei);

    fclose(datei);
    free(vector);

   return(0);

}

groesse ist die größe der zu erzeugenden datei in KB. Ich programmiere unter borland, wobei eine plattformunabhängiger code mir wesentlich lieber wäre!
dass das ganze so *****-lahm ist wird sicher an den übergabewerten für fwrite liegen. Kann man da was optimieren?! Und wie siehts da bei disketten aus?! hab leider kein laufwerk am Rechner, ich muss daher bei mir kompilieren und wo anders testen.

Hab dann gleich noch ne Frage:

Ein freund, der leider verhindert ist, hatte under MS Visual C/C++ mit der sys/timeb.h die Zeit gemessen. Die tut aber weder mit dem LCC noch unter Borland. Gibts was ähnlich genaues?

Bedank mich jetzt schon

CyberTim

zeitmessung hab ich das prob gefunden, aber warum der *****lahm ist weiss ich immernoch net...

frage nebenbei, welche funktion verwendest du zum zeit messen ?

RTC

Hab mal kurz ein Programm zusammen geschustert:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_BLOECKE 256
#define ADD_BLOECKE 8
#define KB_GROESSE  10240

void write_hdd_file(int groesse, int blockgroesse, double *zeit){
    FILE *datei;
    int i;
    char *vector;
    clock_t start, ende;

    if((vector=(char *)malloc(1024*groesse*sizeof(char))) == NULL){
        printf("Speicherplatzmangel\n");
        exit(1);
    }

    for (i=0; i<groesse; i++)
            *(vector+i)='1';

    if((datei = fopen("test.txt", "w+"))==NULL){
        printf("Datei konnte nicht geoeffnet werden...\n");
        free(vector);
        exit(1);
    }

    start=clock();

    for(i=0; i<groesse*1024; i+=blockgroesse)
         fwrite(vector, blockgroesse, 1, datei);

    ende=clock();
    *zeit=(ende-start)/(double)CLOCKS_PER_SEC;

    fclose(datei);
    free(vector);
}

int main(void){
    int i;
    double zeit;

    printf("+--------------+--------------+\n"
        "| Blockgroesse |         Zeit |\n"
        "+--------------+--------------+\n");

    for(i=0; i<=MAX_BLOECKE; i+=ADD_BLOECKE){
        write_hdd_file(KB_GROESSE, (i==0) ? 1 : i, &zeit);
        printf("| %12d | %12.3f |\n", (i==0) ? 1 : i, zeit);
    }

    printf("+--------------+--------------+\n");
    return 0;
}

Die Ausgabe des Programms verdeutlicht, dass eine höhere Blockgröße auch Geschwindigkeitsvorteile bringt. Im Extremfall kannst du die 10MB auch in einem fwrite()-Aufruf abfertigen, your choice! Das mit dem Zeitmessen dürfte sich durch mein Beispielprogramm auch geklärt haben, hoffe ich...

[ Dieser Beitrag wurde am 16.06.2003 um 23:22 Uhr von RTC editiert. ]

RTC

Übrigens ist das Programm auch mit einer Blockgröße von 1 bei mir nicht sehr lahm (0.67 Sekunden für die 10 MB). Keine Ahnung, woran es da bei dir hakt, probier erstmal meinen Code...

Vielleicht kommt Windows nicht so recht damit klar, wer weiß :p

[ Dieser Beitrag wurde am 16.06.2003 um 23:28 Uhr von RTC editiert. ]

CyberTim

Danke erstmal, nach gleich probieren!

hier meine zeitmessung. ist ziemlich 1:1 aus der Hilfe von Borland übernommen, wobei die nen fehler drinne hatten...

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys\timeb.h>
/* Speichern der Tageszeiten des pazifischen Standards */
char *tzstr = "TZ=PST8PDT";

int difftime(void)
{
   struct timeb t1;
   struct timeb t2;
   putenv(tzstr);
   tzset();
   ftime(&t1);

   printf("Seconds since 1/1/1970 GMT: %ld\n", t1.time);
   printf("Thousandths of a second: %d\n", t1.millitm);

   ftime(&t2);
   printf("Seconds since 1/1/1970 GMT: %ld\n", t2.time);
   printf("Thousandths of a second: %d\n", t2.millitm);
   getchar();
   return ((t2.time*1000+t2.millitm)-(t1.time*1000+t1.millitm));
}

wobei ich das eigentlich noch soweit erweitern wöllte, dass ich im main zum beispiel mit...

dauer=difftime(write_hdd_file(groesse));

..aufrufen kann, so dass ich halt in dauer den rückgabewert von difftime speichern kann. und write_hdd_file(groesse) soll halt von difftime aus aufgerufen werden. ich hoffe das geht!

Ich merk schon wieder, C gefällt mir nirgendwie nicht wirklich. in pascal (ist aber zu lange her) hab ich wenigstens alles geblickt und Java macht auch nen schöneren Eindruck (kann ich abeer noch nicht viel)...

[ Dieser Beitrag wurde am 16.06.2003 um 23:58 Uhr von CyberTim editiert. ]

CyberTim

@RTC:

*zeit=(ende-start)/(double)CLOCKS_PER_SEC

blöde frage?! was bedeutet dieses CLOCKS_PER_SEC ???
was bewirkt mir das hier?
was würde rauskommen, wenn ich es weglassen würde?

volkard

ihr messt nicht wirklich mit clock(), wie schnell die platte ist, oder?
(sagt am besten "nein, tun wir natürlich nicht".)

RTC

@volkard: nein, tun wir natürlich nicht
Nee, ich wollte nur die Ablaufgeschwindigkeit testen, wie lang das Programm für den kompletten Schreibdurchlauf braucht. Was andres ist mir auf die Schnelle nicht eingefallen. Wie hättest du es gemacht?

Shade Of Mine

Original erstellt von RTC:
Was andres ist mir auf die Schnelle nicht eingefallen. Wie hättest du es gemacht?

zB aut intel architekturen kann man den ASM Befehl 'rdtsc' (Read Time Stamp Counter) nehmen - der ist ziemlich genu.

unter Windows kann man auch noch mit QueryPerformanceCounter() arbeiten und unter Unix bin ich mir nicht sicher, aber gettimeofday() hat eine aufloesung von millisekunden, das geht auch noch.

virtuell Realisticer

Hi,

gettimeofday() hat sogar eine Aufloesung auf microsekunden

mfg
v R

dEUs

nur theoretisch oder auch praktisch unter jedem os?

nur unter unix

RTC

Original erstellt von CyberTim:
**@RTC:
*zeit=(ende-start)/(double)CLOCKS_PER_SEC
blöde frage?! was bedeutet dieses CLOCKS_PER_SEC ???
was bewirkt mir das hier?
was würde rauskommen, wenn ich es weglassen würde?**

Es würden die Ticks der CPU in dieser Zeit herauskommen. Da du aber keine CPU-Zeit, sondern normale Sekunden haben willst, musst du das Ganze durch die Ticks pro Sekunde (CLOCKS_PER_SEC) dividieren...

volkard

Original erstellt von RTC:
@volkard: nein, tun wir natürlich nicht
Nee, ich wollte nur die Ablaufgeschwindigkeit testen, wie lang das Programm für den kompletten Schreibdurchlauf braucht. Was andres ist mir auf die Schnelle nicht eingefallen. Wie hättest du es gemacht?

ich hätte mich daran erinnert, daß clock die von meinem prozess verbraucte rechenezit misst, und dass das warten auf die platte da nicht dazugehören muss.
weitere folgerungen hätte ich noch geschlossen, aber das überlasse ich dem geneigten leser.

dEUs

Original erstellt von <vr>:
nur unter unix

Bringt also nix unter Windows

RTC

Original erstellt von volkard:
**ich hätte mich daran erinnert, daß clock die von meinem prozess verbraucte rechenezit misst, und dass das warten auf die platte da nicht dazugehören muss.
**

Nicht dazu gehören MUSS oder nicht dazu gehört? Ich habe Bücher gelesen, da wurde auch die Zeit von Schreibvorgängen so gemessen.
Ich meinte eher, wie DU die Zeit eines Schreibvorganges auf die Festplatte messen würdest?!

CyberTim

gettimeofday ist für meine zwecke aber auch nicht wirklich geeignet! da kommen werte bei raus, die zu gut sind! außerdrm brauch ich ne win32-exe wenns fertsch ist, da nützen mir die unix-erweiterungen gar nix...

volkard

Original erstellt von RTC:
Ich meinte eher, wie DU die Zeit eines Schreibvorganges auf die Festplatte messen würdest?!

als uhr nem ich am liebsten rdtsc.

CyberTim

auf die nanosekunde genau brauch ich bei ner 100MB-File nicht die Zeit, ist auch egal...

Hab die Frage schon in der borland-Abteilung gestellt. kann man irgendwie die compile-optimierung abstellen?! hab nämlich das prob, wenn ich ne file shreibe und scnhließen gleich wieder einlesen will, der compi zum lesen 0,00... sekunden braucht. man betone bei 100 MB!