Filezugriff Threadsave reklementieren

Hallo an alle Coder!

Ich habe folgendes Problem: ich habe viele Prozesse in C, die alle Ergebnisse erzeugen und diese dann in EINE Datei zurück schreiben wollen. Ich habe es bisher so gelöst, das ich immer, wenn einer der Prozesse einen Wert an die Datei anhängen will zuvor eine "DateinameUsed.dat" erzeugt und dann beginnt, seine Daten nach "Dateiname.dat" zu schreiben:

usagefile_pointer = fopen( usagefilename, "w" );								// create a new usagefile to indicate usage for other VUsers
	if(usagefile_pointer != NULL) {	
		file_pointer = fopen( filename, "a" );										//  open the data-file
		if(file_pointer != NULL) {													// if data-file is opend - Return with "Error"

			[... Dateibearbeitung ... ]

			fclose( file_pointer );
		} else {																	// if data-file could not be opend
			lr_error_message( "File not found: %s", filename );
		}
		fclose( usagefile_pointer );												// close usageindicator-file
		if (remove(usagefilename) != 0) {											// if usageindicator-file could not be removed
			lr_error_message("Unable to remove %s error %d", usagefilename, remove_errno);
		}
	} else {																		// if usageindicator-file could not be created
		lr_error_message("Not able to create usagefile: %s", usagefilename);
	}

Der komplette Durchlauf vom Erzeugen des Usageindicators bis zum Löschen des Usageindicators dauert ungefähr 0.6 s. What ever - in einem anderen Prozess, welcher jetzt das gleiche machen will prüfe ich also vorher, ob dieses Usageindicator-File existiert:

usagefile_pointer = fopen( usagefilename, "r+" );
	while( usagefile_pointer != NULL  ) {											// wait until nobody accesses the usageindicator-file 
			fclose(usagefile_pointer);					
			waittime = ((rand()%15000)+5000);										// create random value (0.5 -2)
			waittime /= 10000;
			lr_think_time(waittime);												// random wait-time (0.5 - 2 s)
			usagefile_pointer = fopen( usagefilename, "r+" );
	}

Dabei öffne ich die Datei mit und schaue, ob sie existiert. Wenn sie existiert, dann warte ich zufällig zw. 0.5 s und 2 s und versuche dann erneut. Die "lr_Funktionsname()" Funktionen sind spezielle HP LoadRunner Funktionen, mit dem ich im Moment arbeite. "lr_think_time(x)" ist dabei eine Funktion ähnlich dem sleep(x), wobei x eine Zeitdauer in Sekunden angibt.

Nun mein Problem: Wenn mehrere Prozesse gleichzeitig diese Routinen nutzen kommt es irgendwann zu einem Absturz mit Errormeldung wegen eines "runtime errors - memory access violation". Ich gehe davon aus, das entweder bei der Nutzungsprüfung zwischen öffnen und schließen des Usageindicationfiles von einem anderen Prozess das File gelöscht wird, oder das zwei Prozesse gleichzeitig feststellen, das die Datei nicht mehr existiert und sie gleichzeitig neu erstellen wollen!

Ich hoffe, ich habe mein Problem klar machen können und einer von euch kann mir helfen, wie ich dieses Problem in den Griff bekommen kann?!?

Vielen lieben Dank und beste Grüße aus Düsseldorf

mutex, semaphore

Vielen Dank. Ich habe gerade die Wikiartikel studiert. ich kannte zwar die Namen dafür nicht, aber diese Idee an sich ist mir bereits gekommen. Nur konnte ich leider nicht wirklich etwas finden, was es mir in ANSI C ermöglicht eine Unterbrechungssperre zu schalten. Kannst du mir da auf die Schnelle einen Ansatz geben?

AnonymousCoder schrieb:

... was es mir in ANSI C ermöglicht eine Unterbrechungssperre zu schalten ...

Geht nicht in ANSI C. Villeicht aber mit Bibliotheken von deinem Betriebsystem oder Framework.

VIELEN Dank, nochmal! Ich war auch der Meinung, ich sei durch die Tipps ein entscheidendes Stück weiter gekommen: in einer normalen Entwicklungsumgebung kann man damit auch wunderbar Threadsave programmieren - nicht aber im LoadRunner von HP.

Also, ich hab gerade mal noch etwas rumgewühlt, bei google und bin dabei auf www.koders.com gestoßen. Dort kann man sich die benötigten Bibliotheken recht gut zusammen sammeln. Nun habe ich eine nicht enden wollende Kette von ".h" files heruntergeladen und schlassendlich komme ich zu folgenden CompilerErrors:

In file included from [Pfad]\include/pthread.h:5,
                 from globals.h:14,
                 from [Quelldatei]:
[Pfad]\include/signal.h:125:35: #error signal layout not yet known
In file included from [Pfad]\include/signal.h:512,
                 from [Pfad]\include/pthread.h:5,
                 from globals.h:14,
                 from [Quelldatei]:
[Pfad]\include/sys/ucontext.h:119:40: #error NEED TO PORT <sys/sigcontext.h>!

nun fühle ich mich an sich wie ein Noob - denn ich habe keine Ahnung, was der LoadRunner da anstellt, das __i386__ nicht defined ist. Kann mir eventuell ein anderer LoadRunner-User mir einen Tip geben oder könnt ihr mir vlt eine Umgehungslösung empfehlen?

Ich habe überhaupt keine Ahnung, was HP Loadrunner ist ...
Aber ich würde erwägen, einen neuen Prozeß zu schreiben, der nix anderes macht, als die nötigen Dateizugriffe, und den über entsprechende Windowsnachrichten dazu veranlassen, die Daten an die Datei anzuhängen.

Anders wird es wohl leider nicht werden, als das ich mir da nen Dienst schreibe, der den ganzen Spaß verwaltet. Vielen Dank, trotzdem.

Nebenbei habe ich festgestellt, das man anstelle von

usagefile_pointer = fopen( usagefilename, "r+" );
while( usagefile_pointer != NULL  ) {                                            // wait until nobody accesses the usageindicator-file 
    fclose(usagefile_pointer);                    
    // random waittime
    usagefile_pointer = fopen( usagefilename, "r+" );
}

auch einfach nur

while(access(usagefilename, 00) != -1) {
    // random waittime
}

schreiben könnte, sobald man die Funktionen der sys\io.h zur Verfügung hat.

Ich danke trotzdem allen für ihre Antwort!!!

sparrow

Hallo,

ich bin zwar noch Neuling in C, aber kannst du nicht, anstatt direkt in mit jedem Thread in die Datei zu schreiben, einfach einen Spooler in dein Programm einbauen?
Der Spooler ist Threadsicher und bekommt seine Instruktionen von den verschiedenen Threads (Hänge folgendes an die Datei, schreibe folgendes an die und die Stelle....). Diese Instruktionen hält er in einer Warteschlange und arbeitet sie nach und nach ab.

Somit bist du 1. Threadsicher udn 2. sicher auch schneller weil der Overhead zum Öffnen und Schließen der Datei verringert wird, oder?

Gruß
Sparrow