Synchronisation et Memoire partagée

Signaler
Messages postés
9
Date d'inscription
mercredi 5 mai 2004
Statut
Membre
Dernière intervention
15 novembre 2005
-
Messages postés
9
Date d'inscription
mercredi 5 mai 2004
Statut
Membre
Dernière intervention
15 novembre 2005
-
Voila, j'ai deux executables que je veux synchroniser et entre lesquels je veux echanger des données.

Pour l'echange des données : j'utilise le FileMapping
Pour la synchronisation : j'utilise les Mutex

Mon programme merde au niveau de la synchronisation, qui veux regarder ?

Organigramme desire

Le serveur Le client
Stocke valeur dans FileMapping Attend
Libere le client Attend
Attend Recupere valeur dans
FileMappingAttend Affiche les valeurs
Attend Libere le serveur

Voila les fichiers :

///////////////////////
///////////////////////
Serveur.cpp :
///////////////////////
///////////////////////

#include <windows.h>
#include

using namespace std;

#include "..\Commun\Commun.hpp"

int main(int argc, char* argv[])
{
HANDLE fileHandle;
HANDLE mapFileHandle;

struct Transfert *mdata = NULL;

mapFileHandle = CreateFileMapping(INVALID_HANDLE_VALUE,
NULL,
PAGE_READWRITE,
0,
sizeof(struct Transfert),
"TEST");

if(mapFileHandle <= 0)
{
cout << "Unable to create file mapping" << endl;
system("PAUSE");
return 0;
}

mdata = (struct Transfert *)MapViewOfFile(mapFileHandle,
FILE_MAP_WRITE,
0,
0,
0);

for (int i = 0 ; i < 5 ; i++)
{
HANDLE Mutex_Client = CreateMutex(NULL,
TRUE,
"Mutex_Client_Bilbo");

HANDLE Mutex_Serveur = OpenMutex(MUTEX_ALL_ACCESS,
FALSE,
"Mutex_Serveur_Bilbo");

for(int j = 0 ; j < MAXMEMORY ; j++)
{
mdata->data[j] = ( i * 10 ) + j;
}

cout << "j'attend 5 sec pour lacher le client" << endl;
Sleep(5000);
cout << "je lache le client" << endl;

CloseHandle(Mutex_Serveur);

ReleaseMutex(Mutex_Client);

while(WaitForSingleObject(Mutex_Serveur, INFINITE) == WAIT_FAILED)
{
cout << "j'attend en attendant que le client finisse" << endl;
}

CloseHandle(Mutex_Client);
}

if(!UnmapViewOfFile(mdata))
{
cout << "unable to unmap"
<< endl;

system("PAUSE");
}

cout << endl;
cout << endl;

cout << "Pause avant fermeture du mapping"
<< endl;

cout << endl;
cout << endl;

system("PAUSE");

CloseHandle(mapFileHandle);
CloseHandle(fileHandle);

system("PAUSE");
return 0;
}

///////////////////////
///////////////////////
Client.cpp :
///////////////////////
///////////////////////

#include <windows.h>
#include

using namespace std;

#include "..\Commun\Commun.hpp"

int main(int argc, char* argv[])
{
HANDLE mapFileHandle;

struct Transfert * mdata = NULL;

// Ouverture du mapping
mapFileHandle = OpenFileMapping(FILE_MAP_READ,
TRUE,
"TEST");

if (!mapFileHandle)
{
cout << "Impossible d'ouvrir le partage"
<< endl;

system("PAUSE");
return 1;
}

mdata = (struct Transfert *)MapViewOfFile(mapFileHandle,
FILE_MAP_READ,
0,
0,
0);

cout << "File Mapping"
<< endl;

for (int i = 0 ; i < 5 ; i++)
{
HANDLE Mutex_Client = OpenMutex(MUTEX_ALL_ACCESS,
FALSE,
"Mutex_Client_Bilbo");

HANDLE Mutex_Serveur = CreateMutex(NULL,
TRUE,
"Mutex_Serveur_Bilbo");

while(WaitForSingleObject(Mutex_Client, INFINITE) == WAIT_FAILED)
{
cout << "j'attend que le serveur lache la main"
<< endl;
Sleep(100);
}

cout << endl
<< "Etape "
<< i
<< endl;

for(int i=0;i<MAXMEMORY;i++)
{
cout << mdata->data[i] << endl;
}

Sleep(10000);

cout << "je lache le serveur"
<< endl;

CloseHandle(Mutex_Client);

ReleaseMutex(Mutex_Serveur);

CloseHandle(Mutex_Serveur);
}

if(!UnmapViewOfFile(mdata))
{
cout << "Impossible de faire unmap" << endl;
}

CloseHandle(mapFileHandle);

system("PAUSE");
return 0;
}

1 réponse

Messages postés
9
Date d'inscription
mercredi 5 mai 2004
Statut
Membre
Dernière intervention
15 novembre 2005

Mon organigramme est pas clair :

Le serveur :::: Le client
Stocke valeur dans FileMapping :::: Attend
Libere le client :::: Attend
Attend :::: Recupere valeur dans FileMapping
Attend :::: Affiche les valeurs
Attend :::: Libere le serveur

et sa boucle bien sur