l3.libnazgul/src/nzg_allocate.c

#include "libnazgul.h"
#include "nzg_ids.h"

/* TODO: remplacer le bool de msgPoolData par un identifiant
   de semaphore. Le semaphore contient poolNb valeurs (et indique
   donc le nombre de ressources disponnibles).

*/

#define ANYPOOL -1
#define SPECIFICPOOL 0

void * msgAllocate(msgSpace *space,
	int pool,
	int taille,
	int option
	){

  void * resultAddr;
  int i, mSPoolDataTabFd;
  msgPoolId resultPoolID;
  /* tableau des valeurs des semPoolCoef/pool pour identifier le pool
   * qui sera lib<EFBFBD>r<EFBFBD> le plus rapidement */
  float semPoolCoef[space->poolNb]; 
  int idxPoolOptimum;
  
  bool gotRessourceSem;

  msgPoolDataId poolDataId;
  sem_t * poolDataSemFd;
  
  msgPoolDataSemId ressourceSemId;
  sem_t * ressourceSemFd;
  int * ressourceSemVal;
  float minPoolCoef;

  
  /* TODO: verifier le premier arg du shm_open */
  mSPoolDataTabFd=shm_open(space->poolDataId,O_RDWR,MSGSPACE_DEFAULT_MODE);
  if (mSPoolDataTabFd == -1 ) {
	fprintf( stderr, "Allocate %s failed: %s\n",
		(char*)space->poolDataId,
		strerror( errno ) );
	return NULL;
  }

  msgPoolData * mSPoolDataTab;

  mSPoolDataTab = mmap( 0, (space->poolNb) * sizeof( msgPoolData ),
	  PROT_READ | PROT_WRITE,
	  MAP_SHARED, mSPoolDataTabFd, 0 );

  if( mSPoolDataTab == MAP_FAILED) {
	fprintf( stderr, "mmap failed: %s\n",
		strerror( errno ) );
	return NULL;
  }

	gotRessourceSem=false;
  int gotIdx=-1;

  /* initialisation des coefs */
  for (i=0;i<(space->poolNb);i++){
	semPoolCoef[i]=-1;
  }
  
  int nbLockedSem=0;
  if ( pool == ANYPOOL){
	// choisir le pool au hasard (ou presque)
	poolDataSemFd=sem_open(space->poolDataSemId,0);
	for(i=0; i<(space->poolNb); i++) {
	  if(mSPoolDataTab[i].bufferSize >= taille) {
		/* choisir le numero du semaphore
		   en fonction du nombre de lock poses / nombre de buffer */
		ressourceSemFd = sem_open(mSPoolDataTab[i].id,0);
		/* on remplit le tableau avec les valeurs des semaphores */
		sem_getvalue(ressourceSemFd, ressourceSemVal);		
		if ((*ressourceSemVal) < 0){
		  semPoolCoef[nbLockedSem] = (float) (- (*ressourceSemVal) / mSPoolDataTab[i].bufferNb);
		  nbLockedSem++;
		}
		if(sem_trywait(ressourceSemFd)) {
		  /* choisir la 1ere pool de taille plus grande 
		   * libre si possible */
		  gotRessourceSem=true;
		  gotIdx=i;
		  strcpy(resultPoolID,mSPoolDataTab[gotIdx].id);
		  break;
		}
	  } // if buffSize > taille
	} // for

	if (!gotRessourceSem) {		
	  minPoolCoef= semPoolCoef[0];
	  idxPoolOptimum = 0;
	  /* on cherche le pool avec le moins de lock poses / nbre de buffer
	   * le num<EFBFBD>ro du pool est stock<EFBFBD> dans idxPoolOptimum */
	  for(i=0; i<nbLockedSem; i++) {
		if ((semPoolCoef[i] != -1) 
			&& (semPoolCoef[i] < minPoolCoef)) {
		  minPoolCoef = semPoolCoef[i];
		  idxPoolOptimum = i;
		}
	  }

	  if (minPoolCoef == -1){
		/* il n'y a aucune pool dont la taille satisfait la demande */
		return NULL;
	  } else {
		if (sem_wait(ressourceSemFd) < 0){
		  perror("sem_wait");
		}		
		strncpy(resultPoolID,
			mSPoolDataTab[idxPoolOptimum].id,
			MSGSPACE_ID_LEN*4
			);
	  }
	}
  }else {
	
	ressourceSemFd=sem_open(mSPoolDataTab[i].id,0);
	if (sem_wait(ressourceSemFd) < 0){
		  perror("sem_wait");
		}		

	strncpy(resultPoolID,
		mSPoolDataTab[pool].id,
		MSGSPACE_ID_LEN*4
		);
  }

  /* on a acqui un semaphore pour la ressouce */
  /* on modifie maintenant les donn<6E>es */
  /* TODO:
   dataRWsem=semOpen(,0);
   sem_wait(dataRWsem);
   sem_close(dataRWsem);
   */
  
  /* trouver un buffer libre, ou dormir */
  
  /* TODO: mapper le buffer dans l'esp addr du proc */

  /* TODO: unmapper le msgPoolDataTab */


  return resultAddr;
}