Speicherzugriff

Tentone

Hallo Leute,

also manchmal kann man mit dem Thema Pointer, Zeiger, Adressierung richtig verzweifeln. Beisse mir schon seit Tagen die Zähne daran aus , deshalb hier der Hilferuf!
Folgendes Problem ich steuer drei Threads die über eine "gemeinsame" Variablen struktur in Verbindung stehen.

D.h. liest der client Zeichen aus dem RECV-Befehl aus, dann soll der Write Befehl aktiv werden und die Zeichen in eine Datei ablegen.
Dies macht er auch ganz braf. Bis auf ein paar Zeichen (meist immer die ersten vier) die falsch sind.

D.h. ich bin der Meinung, dass ich irgend etwas falsch mache mit der Speicherübergabe und keine Ahnung habe was .
Ich habe mal hier unten den Aufruf der Threads hineingestellt und weiter unten den write-Thread.

Auszug aus Main:

[cpp]

extern int client(struct FLAG *client_param);
extern DWORD WINAPI handle_error(struct FLAG *check_flag);
extern int write(struct FLAG *write_param);
extern int convert(struct FLAG *convert_flag);

int main()
{
	FLAG *error_flag = (FLAG*)malloc(sizeof(FLAG));
	HANDLE  hThreadArray[MAX_THREADS]; 
	DWORD   dwThreadIdArray[MAX_THREADS];

	InitializeCriticalSection(&cs);
	error_flag->initiate=-1;
	error_flag->signal[0]=ENABLE_RECV;
	error_flag->signal[1]=BLOCK_WRITE;
	error_flag->signal[4]=START_SERVER;
	error_flag->flag=BUFFER_FREE;
	error_flag->recieved=0;

	//Create the thread
	hThreadArray[0]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)client, error_flag, 0, &dwThreadIdArray[0]);
	//hThreadArray[1]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)handle_error, error_flag, 0,&dwThreadIdArray[1]);
	hThreadArray[2]=CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)write, error_flag, 0, &dwThreadIdArray[2]);
	// CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)convert, error_flag, 0, 0);

Der Write-Thread (die Datei test.pdf ist nur ein Testname, versende einfach eine PDF Datei, die ich dann abspeichern will):

[cpp]

extern CRITICAL_SECTION cs;
int write(struct FLAG *write_param)
{
	FILE *fp;
	int i=0;
	for(;;)
	{
		EnterCriticalSection(&cs);
		if (write_param->flag==BUFFER_FILLED && write_param->signal[0]==BLOCK_RECV)
			write_param->signal[1]=ENABLE_WRITE;

		if (write_param->signal[1]==ENABLE_WRITE)
		{
			fp=fopen("test.pdf","rb+");
			if (fp==NULL)
				fp=fopen("test.pdf","wb");
			else
				fseek(fp,0,SEEK_END);
			if(write_param->signal[3]==NEW_HEADER)
			{
				fp=fopen("test.pdf","wb");
				write_param->signal[3]=OLD_HEADER;
			}
			else
				fseek(fp,0,SEEK_END);

			for(i=0;i<write_param->recieved;i++)
			{	
					fputc(write_param->buffer[i],fp);
			}
			fclose(fp);
			write_param->signal[1]=BLOCK_WRITE;
			write_param->signal[0]=ENABLE_RECV;
			write_param->flag=BUFFER_FREE;
			memset(write_param->buffer,0,strlen(write_param->buffer)); 
			write_param->recieved=0;

		}
		LeaveCriticalSection(&cs);
	}
}

BorisDieKlinge

hmm ich hab mir dein code nich richt angeschaut, aber so wie ich das überlogen habe, hast du 2 threads, einer liest DIE daten und der andere schreibt DIESE Daten. korrekt?

und wenn du dein Programm startetst, sind die ersten zeichern falsch (die vom wirte thread) geschrieben werden , korrekt?

vll. solltest du die thread syncronisieren, so das der write thread erst daten schreiben, wenn der read thread überhaupt schon daten gelesen hat.... sonstkom nur müll raus.

Tentone

Hallo,

danke für Deine Antwort.
Aber diese Beiden (Read und Write) Threads habe ich mittels Flags synchronisiert.
Und trotzdem kommt nur Quatsch raus. Komisch ist nur, dass es die ersten vier Bits sind.

Gruß und erstmal danke
Tentone

BorisDieKlinge

hmm... wo ist die read funktion?

Wie machst das denn eigentlich? bzw. wie syncronisierst du das?

Readthread list X Bytes, währendessen wartet write thread?
Writthread schreibt diese X Bytes, währenddessen wartet readthread?

du erzeugst ja zuerst den Read thread , und gehst davon aus das dieser als erstes startet um die ersten bytes zu lesen. Naja aber das ist nich gewährleistet.

du sollst deine thread mit events syncronisieren WaitForsingleObject. SetEvent
Reset Event

extern HANDLE eWrite;
extern HANDLE eRead;

int main(void){
eWrite= CreateEvent(...);
eRead= CreateEvent(...);
.
.
.
//Thread erzeugen
}
int write(struct FLAG *write_param)
{

 WaitForSingleObject(eWrite,INFINTE);
 // SCHREIBEN
 SetEvent(eRead);
 ResetEvent(eWrite);

}

int read(struct FLAG *write_param)
{

 WaitForSingleObject(eRead,INFINTE);
   // LESEN
 SetEvent(eWrite);
 ResetEvent(eRead);

}

Tentone

Danke für Deine Antwort.

Werde ich probieren, kann aber sein, dass ich nochmal Lauthals HILFE rufe:) ....

Gruß und schönen Tag noch

Tentone