int main()
{
Liste *maListe = initialisation();
printf("%d\n", compteur(maListe));
insertion(maListe, 4);
insertion(maListe, 8);
insertion(maListe, 15);
insertion(maListe, 6);
insertion(maListe, 9);
insertion(maListe, 18);
// suppression(maListe);
printf("%d\n", compteur(maListe));
insertdebut(maListe,1);
insertfin(maListe, 99);
afficherListeAvant(maListe);
printf("===\n");
afficherListeArriere(maListe);
courantavant(maListe);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
remplcourav(maListe, 666);
insertcourav(maListe, 888);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
printf("%d-", maListe->courant->nombre);
courantarriere(maListe);
remplcourar(maListe, 999);
insertcourar(maListe, 777);
printf("%d-", maListe->courant->nombre);
courantavant(maListe);
printf("%d-", maListe->courant->nombre);
courantavant(maListe);
printf("%d\n\n", maListe->courant->nombre);
afficherListeAvant(maListe);
printf("%d\n", compteur(maListe));
return 0;
}
int getResults(int ntest)
{
int i, c;
int resultat = 0;
/* On comptabilise les resultats distants */
/* Add remote test results */
for (c = 0; c < maxClients; c++) {
for (i = 0; i < dp.nclnt; i++) {
serverReceiveClient(c);
unSerialiseResult(&resultat);
compteur(resultat, ntest);
}
}
/* On comptabilise les resultats locaux */
/* Add local test results */
for (i = 0; i < dp.nclnt; i++) {
read(maitreLecteur, message, M_SIZE);
unSerialiseResult(&resultat);
compteur(resultat, ntest);
}
return 0;
}
char *my_strncpy(char *dest, char *src, int n)
{
int i;
int compt;
i = 0;
while (i < n)
{
dest[i] = src[i];
i = i + 1;
}
compt = compteur(src);
if (n > compt)
dest[compt] = '\0';
return (dest);
}
void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
setup_low_volt_detect(FALSE);
//Setup_Oscillator parameter not selected from Intr Oscillotar Config tab
//intitSerie(31);
set_tris_a(0b00101111);
set_tris_c(0b11111101);
Set_tris_D(0b11100000); // port D : Led
lectureTrame();
while(true){
if(truc=='c'){
clignotement();
}
if(truc=='j'){
johnson();
}
if(truc=='t'){
compteur();
}
if(truc=='h'){
chenillard();
}
}
}
double int_montecarlo_save(double(*f)(double),double a, double b,int n)
{ int i;
double res=0.0;
int c;
FILE *fichier=NULL;
fichier = fopen("resultat.txt", "a");
res=get_last("resultat.txt");
for ( i=compteur("resultat.txt");i<n;i++)
{
res+=f(a+rand()*1.0/RAND_MAX*(b-a));
fprintf(fichier,"%f",res);
fputc(' ',fichier);
}
return res/n;
}
void maitre(struct donneesPub *dp)
{
int i,n,a,bl;
int clnt, reception;
int r;
char tmp[MAXLEN], *buf;
struct flock request;
struct s_test tLock;
enum etat_t etat;
char phraseTest[]="Ceci est une phrase test écrite par le maitre dans le fichier";
clnt=dp->nclnt;
reception=dp->maitre[0];
etat=SELECT;
/* On commence par le premier test */
n=0;
printf("\n--------------------------------------\n");
while(1){
switch(etat){
case SELECT:
/* Selection du test à effectuer*/
printf("\n");
E("Maitre: SELECT");
selectTest(n, &tLock);
etat=tLock.type;
bl=0;
if(n<MAXTEST){
memset(tmp,0,MAXLEN);
sprintf(tmp,"TEST : TRY TO %s:",LISTE_NOMS_TESTS[n]);
write(0, tmp, strlen(tmp));
}
else
etat=FIN;
P("etat=%d\n", etat);
n+=1;
continue;
case RDONLY: /* Not reached */
case WRONLY: /* Not reached */
case READLOCK:
P("Read lock :%d\n", etat);
request.l_type=F_RDLCK;
etat=LOCK;
continue;
case WRITELOCK:
P("Write lock :%d\n", etat);
request.l_type=F_WRLCK;
etat=LOCK;
continue;
case LOCK:
/* On applique le lock que l'on veut */
E("Maitre: LOCK");
write(dp->fd,phraseTest,strlen(phraseTest));
lockWholeFile(&request);
if(fcntl(dp->fd, F_SETLK, &request)<0){
perror("Master: can't set lock\n");
perror("Echec\n");
exit(0);
}
sleep(1);
E("Maitre");
etat=SYNC;
continue;
case BYTELOCK_READ:
bl=1;
request.l_type=F_RDLCK;
etat=SYNC;
continue;
case BYTELOCK_WRITE:
bl=1;
request.l_type=F_WRLCK;
etat=SYNC;
continue;
case BYTELOCK:
/* L'idée est de faire locker l'ensemble du fichier octet par octet par un ensemble de sous processus
* Il nous faut donc
* -créer un fichier ayant autant d'octet que le nombre de processus passé en paramètres
* -passer les sections à locker à chacun des esclaves
* -vérifier que les locks sont bien appliqués
* */
/* On crée une chaine de caractères à enregistrer dans le fichier qui contienne exactement un octet par
* processus.
*/
P("Maitre: BYTELOCK: %d\n", etat);
buf=(char *)malloc(clnt);
memset(buf,'*', clnt);
write(dp->fd, buf, clnt);
request.l_whence=SEEK_SET;
/* Chaque processus esclave reécrit son champs à locker. */
for(i=0;i<clnt;i++){
/* On renseigne la structure avec le lock qui va bien */
request.l_start=i;
request.l_len=1;
write(dp->lclnt[i][1], &request, sizeof(struct flock));
}
etat=RESULTAT;
continue;
case SYNC:
/* Synchronisation des processus esclaves. */
P("Maitre: SYNC %d\n", etat);
/* On configure les esclaves pour le test */
for(i=0; i<clnt; i++)
write(dp->lclnt[i][1], &(tLock.test), sizeof(int));
if(bl){
etat=BYTELOCK;
continue;
}
if(n<MAXTEST+1) etat=RESULTAT;
else etat=FIN;
continue;
case RESULTAT:
/* On lit les résultats un par un */
E("Maitre: RESULTAT");
for(i=0; i<clnt; i++){
if((a=read(reception, &r,sizeof(int)))<0){
perror("Can't read master pipe");
exit(1);
}
compteur(r,n-1);
}
if(bl) validationResultats(n-1, dp);
etat=CLEAN;
continue;
case CLEAN:
a=CLEAN;
for(i=0; i<clnt; i++)
write(dp->lclnt[i][1], &a, sizeof(int));
/* Get CLEAN AcK from slaves */
for(i=0; i<clnt; i++){
if(read(reception, &a,sizeof(int))<0){
perror("Can't read master pipe");
exit(1);
}
}
/* close and open file */
close(dp->fd);
initTest(dp);
etat=SELECT;
continue;
case FIN:
a=FIN;
for(i=0; i<clnt; i++)
write(dp->lclnt[i][1], &a, sizeof(int));
break;
printf("(end)\n");
exit(0);
}/* switch */
break;
}/* while */
rapport(clnt);
}
