unendlich grosses File erzeugen

Jey

Moin Moin,

Ich versuche gerade, zu einem reinen Lerneffekt, ein Programm zu schreiben, dass mir ein beliebig grosses File erzeugt.
Das Programm ist simpel gehalten, es fragt ganz einfach nach der gewünschten grösse in MegaBytes und erstellt dann ein .dat File, welches durch eine For-Schleife mit je einem MB '\0' beschrieben wird.

Nun das interessante: Ich kann ohne weitere Probleme ein 1GB grosses File erstellen. Doch wenn ich nun ein 10GB grosses File erstellen will, geht das bis 2.1GB grösse, dann wird das programm mit "return 0" abgeschlossen -> kein Systemfehler.

Hier der Code:

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

#define DATAFILE "data.dat"

void write()
{
	FILE *fp;
	unsigned char data[1024 * 1000];						// ein MegaByte gross
	data[0] = '\0';

	fp = fopen(DATAFILE, "a+b");
	fwrite(&data, sizeof(data), 1, fp);
	fclose(fp);
}

int main(int argc, char *argv[])
{
	FILE *fp;
	unsigned long long mbytes = 0;
	unsigned long long a = 0;

	fp = fopen(DATAFILE, "w+");
	fclose(fp);

	printf("Bitte geben Sie die gewünschte Dateigrösse in MBs an: ");
	do{ scanf("%d", &mbytes); }while(getchar() != '\n');

	for(a; a<mbytes; a++)
	{
		write();
	}

	return 0;
}

Was Mache ich falsch? Bitte versucht nicht einen tiefer Sinn in dem Programm zu erkennen, es ist wirklich aus reinen Lerngründen entstanden.

Zum System: Ich programmiere auf Linux Mint (basierend auf Ubuntu). Als Compiler nutze ich gcc. Die IDE ist Geany, was ja eigentlich egal ist.
als erstes dachte ich, dass es am RAM liegt. 2.1Gb -> 21000 blöcke. Zu diesem Zweck habe ich nun ein System mit 4GB, eines mit 2GB und eines mit 700MB RAM getestet, jedes mal mit dem selben Ergebnis.

Ich danke euch für euere Hilfe!

Gruss Jey

volkard

das sieht alles ok aus. 2.1G ist gerade 2^31, als wenn da ein 32-bittiger zähler umschlagen würde. vierlleicht einer in der FILE-struct? probiers mal ohne FILE. vielleicht mit open statt fopen.

Jey

hallo volkard

Kannst du mir bitte etwas mehr dazu sagen? Ich programmiere noch nicht so lange in C.

Vielen Dank

volkard

Jey schrieb:

Kannst du mir bitte etwas mehr dazu sagen? Ich programmiere noch nicht so lange in C.

Ahso. Na, dann probiere zuerst mal, auf die Funktion write zu verzichten und dafür die Datei nicht dauernd zu öffnen und zu schließen. Vielleicht reicht das schon.

Die alternative wäre, bei man open und man write und man close zu schauen, und zu versuchen, diese Funktionen zu benutzen. Die sollten eigentlich keine Beschränkungen haben.

Jey

also nur das file nicht mehr bei jedem funktionsaufruf zu öffnen und zu schliessen hat nichts verändert.

volkard

Wie groß ist denn die maximale Dateigröße Deines Dateisystems?
Kannste mit dd so ein großes File machen?

Jey

Jo, habs mit dd probiert, kann ohne probleme ein 10GB grosses File erzeugen :>

volkard

evtl hilft auch
#define _FILE_OFFSET_BITS 64
als erste Zeile vor dem includen.
http://www.suse.de/~aj/linux_lfs.html

Jey

erstaunlich, es funktioniert! hab jetzt ne 10GB grosse Datei in meinem Verzeichnis

Ich danke dir vielmals!

Für alle die es interessiert, hier der Code:

#define _FILE_OFFSET_BITS 64 			//Damit grösser als 2GB
#include <stdio.h>
#include <stdlib.h>

#define DATAFILE "data.dat"				//dateiname festlegen

void write()							//funkion schreibt je ein MB
{
    FILE *fp;
    unsigned char data[1024 * 1000];                        // ein MegaByte gross
    data[0] = '\0';

    fp = fopen(DATAFILE, "a+b");
    fwrite(&data, sizeof(data), 1, fp);
    fclose(fp);
}

int main(int argc, char *argv[])
{
    FILE *fp;
    unsigned long long mbytes = 0;
    unsigned long long a = 0;

    fp = fopen(DATAFILE, "w+");
    fclose(fp);

    printf("Bitte geben Sie die gewünschte Dateigrösse in MBs an: ");
    do{ scanf("%d", &mbytes); }while(getchar() != '\n');

    for(a; a<mbytes; a++)
    {
        write();
    }

    return 0;
}

P.S.: wenn ich die Datei vor der for-Schleife öffne und danach wieder schliesse hat sich das Programm manchmal mit einer Fehlermeldung verabschieded -> unstable

Vielen Dank noch einmal!

Greez Jey

SeppJ

Jey schrieb:

P.S.: wenn ich die Datei vor der for-Schleife öffne und danach wieder schliesse hat sich das Programm manchmal mit einer Fehlermeldung verabschieded -> unstable

Dann machst du etwas falsch.

Du musst die Datei vor der Schleife öffnen und sie auch geöffnet halten. Write bekommt als Argument das Objekt (FILE*) übergeben und schreibt dann jeweils in die Datei.
Außerdem ist es normalerweise keine gute Idee, 1MB auf den Stack zu schieben. Du solltest den Speicher vorher auf dem Heap allokieren und diesen Bereich ebenfalls der Funktion als Argument übergeben.

volkard

[quote="Jey"]

#define _FILE_OFFSET_BITS 64 			//Damit grösser als 2GB
#include <stdio.h>
#include <stdlib.h>

#define DATAFILE "data.dat"				//dateiname festlegen

int main(int argc, char *argv[])
{
    FILE *fp;
    unsigned long long mbytes = 0;
    unsigned long long a = 0;
    unsigned char data[1024 * 1000];//malloc!

    fp = fopen(DATAFILE, "w+");fclose(fp); //unlink?

    printf("Bitte geben Sie die gewünschte Dateigrösse in MBs an: ");
    do{ scanf("%d", &mbytes); }while(getchar() != '\n');

    data[0] = '\0'; //memset!

    fp = fopen(DATAFILE, "a+b");
    for(a; a<mbytes; a++)
    {
        fwrite(&data, sizeof(data), 1, fp);
    }
    fclose(fp);
    //free!

    return 0;
}

Hallo

Geht bei mir wunderbar doch. wenn ich die datei wieder offnen will (nachdem ich sie geschlossen habe) dn funktioniert das schon nicht mehr !
Wie mach ich den das ?

gr.fr

Wutz

Das Problem ist der gewählte append-Modus bei fopen. Bei jeder Schreiboperation versucht dieser, ans Dateiende zu positionieren, was bei üblicher Definition von fpos_t==long genau LONG_MAX (auf 32-Bit Compilern 2^31) entspricht. Die Position vor dem Schreiben mit fwrite kann also max. LONG_MAX betragen.

_FILE_OFFSET_BITS ist kein ANSI C
unsigned long long ist kein C89
1024*1000 ist ungleich 1 MB
...

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

#define DATAFILE "data.dat"                //dateiname festlegen

int main()
{
    FILE *fp;
    long mbytes;
    unsigned char *data=calloc(1,1<<20L);

    printf("Bitte geben Sie die gewünschte Dateigrösse in MBs an: ");
    do{ scanf("%ld", &mbytes); }while(getchar() != '\n');

    if( fp = fopen(DATAFILE, "wb") )
    {
      while( mbytes-- )
        if( 1!=fwrite(data, 1<<20L, 1, fp) )
          perror(DATAFILE),fclose(fp),free(data),exit(1);
      fclose(fp);
    }    
    free(data);

    return 0;
}

Wutz schrieb:

1024*1000 ist ungleich 1 MB

Ja, stimmt. Bei 1024*1024 Bytes auf dem Stack dürfte sich das Programm aber auch kommentarlos verabschieden.

* Es sei denn, man reserviert zusätzlichen Speicher für Stack-Allokationen.

Hallo

Ja und jetzt ? gibt es nun eine Funktion mit der ich 10GB Files öffnen kann ?
Den Rest weiss ich alles.

gr.fr

volkard

fr schrieb:

Ja und jetzt ? gibt es nun eine Funktion mit der ich 10GB Files öffnen kann ?
Den Rest weiss ich alles.

Jetzt wäre es an der Zeit, open zu probieren?

Hallo

Danke.
Gibt es den auch etwas vergleichbares zu fseek(), da diese ja auch nur mit 32Bit umgehen kann !?

gr.fr

volkard

fr schrieb:

Hallo
Danke.
Gibt es den auch etwas vergleichbares zu fseek(), da diese ja auch nur mit 32Bit umgehen kann !?
gr.fr

Hier steht mehr: http://yfrog.com/9eopengp
Sagst mir bescheid, wenn ich nach unten scrollen soll oder einem Verweis folgen.