Modelisation de system
Afin de présenter la fonctionnement réel autant plus possible, on divise le process fork en profondeur c-à-dire, on pense que la génération de fork sont synchronizées et on garde le nombre de processus existantes en cours, et chaque fois, on génère les fils en fonction de nb de processus de la dernière génération. Tout en dehors, on calcule l’expérance de nnn fois pour obtenir un résultat plus correct. Comme il existe la probabilité que le système s’explode et ne s’arrêterait pas, on définie que notre génération est limité à 10 fois. Et pour le cas ou la borne de convergence se trouve, on n’observe que un nombre minimale et faisable pour que notre expérimentation soit possible. Pour ceux qui exécute fork avec la proba de p0, on considère que ces processus vont se terminer au temps fini, donc on les enlève tout simplement au moment ou ils exécute le fork pour que notre système soit propre et correct. Dans ce cas là, si le système est convergent, au temps fini, on pourrait observer qu’il n’existera ancun processus.
set.seed(73)
# library(igraph)
#Generateur suit la loi de Bernouilli
generate_B<-function(genTotal=1,p=0.5){
numPro = array(0,genTotal) #number of process at each generation
numPro[1] = 1
numGen = 1 #number of generation
pro=runif(1)
flag_create=0
#create processes
while((pro <= p || numPro[numGen]>1) && numGen<genTotal){
for(i in 1:numPro[numGen]){
if(pro<=p){
if(flag_create==0){
numPro[numGen+1]=0
flag_create=1
}
numPro[numGen+1] = numPro[numGen+1]+2
}
pro = runif(1)
}
if(flag_create==1){
numGen=numGen+1
flag_create=0
}else{break}
}
# plot(numPro)
numPro
}
#Generator suit la loi de Binomiale
generate_Bin<-function(genTotal=1,p=0.5,n=100){
numPro = array(0,genTotal) #number of total process at each forking generation
numGen = 1 #number of forking generation
numPro[numGen] = 1
pro=runif(1)
pk=c()
pk[1]=(1-p)^n #range of 'p0' : 0~p0
#range of pk is p[i-1]
for(i in 2:(n+1)){
pk[i]=pk[i-1]+(choose(n, i-1))*(p^(i-1))*((1-p)^(n-i+1))
}
flag_create=0
while((pro>pk[1] || numPro[numGen]>1) && numGen<genTotal){
for(i in 1:numPro[numGen]){
if(pro > pk[1]){
if(flag_create==0){
numPro[numGen+1]=0
flag_create=1
}
for(j in 1:n){
if(pro<=pk[j+1]){
numPro[numGen+1] = numPro[numGen+1]+j
break
}
}
}
pro = runif(1)
}
if(flag_create==1){
numGen=numGen+1
flag_create=0
}else{break}
}
# plot(numPro,type="b")
numPro
}
#Generator suit la loi de geometrique
generate_Geo<-function(genTotal=10,p=0.5){
numPro = array(0,genTotal) #number of total process at each forking generation
numGen = 1 #number of forking generation
numPro[numGen] = 1
pro=runif(1)
pk=c()
pk[1]=p #range of 'p0' : 0~p0
flag_create=0
while((pro>pk[1] || numPro[numGen]>1) && numGen<genTotal){
for(i in 1:numPro[numGen]){
if(pro > pk[1]){
if(flag_create==0){
numPro[numGen+1]=0
flag_create=1
}
j=1
pk[j+1]=pk[j]+p*(1-p)^j
while(TRUE){
if(pro<=pk[j+1]){
numPro[numGen+1] = numPro[numGen+1]+j
break
}else{
j=j+1
pk[j+1]=pk[j]+p*(1-p)^j
}
}
}
pro = runif(1)
}
if(flag_create==1){
numGen=numGen+1
flag_create=0
}else{break}
}
# plot(numPro)
numPro
}
#Generator suit la loi de Poisson
generate_Poisson<-function(genTotal=10,p=3){
numPro = array(0,genTotal) #number of total process at each forking generation
numGen = 1 #number of forking generation
numPro[numGen] = 1
pro=runif(1)
pk=c()
pk[1]=exp(-p) #range of 'p0' : 0~p0
flag_create=0
while((pro>pk[1] || numPro[numGen]>1) && numGen<genTotal){
for(i in 1:numPro[numGen]){
if(pro > pk[1]){
if(flag_create==0){
numPro[numGen+1]=0
flag_create=1
}
j=1
pk[j+1]=pk[j]+exp(-p)*(p^j)/factorial(j)
while(TRUE){
if(pro<=pk[j+1]){
numPro[numGen+1] = numPro[numGen+1]+j
break
}else{
j=j+1
pk[j+1]=pk[j]+exp(-p)*(p^j)/factorial(j)
}
}
}
pro = runif(1)
}
if(flag_create==1){
numGen=numGen+1
flag_create=0
}else{break}
}
# plot(numPro)
numPro
}
creer_fils<-function(genTotal=10,p=0.5,loi='b',n_binomial=10){
switch(loi,
'b'={generate_B(genTotal,p)},
'bin'={generate_Bin(genTotal,p,n_binomial)},
'geo'={generate_Geo(genTotal,p)},
'poisson'={generate_Poisson(genTotal,p)})
}Loi Bernouilli
par(mfrow = c(1,3))
nnn=1000
nnnBorne = 100
nnnSup = 10
nbIte=30
simuB1=array(0,nnn)
simuB2=array(0,nnnBorne)
simuB3=array(0,nnnSup)
for(i in 1:nbIte){
simuB1=creer_fils(nnn,0.5,'b')+simuB1
simuB2=creer_fils(nnnBorne,0.51,'b')+simuB2
simuB3=creer_fils(nnnSup,0.7,'b')+simuB3
}
print('bernouilli')## [1] "bernouilli"plot(simuB1/nbIte,xlim=c(0,nnn),type="b",main = "bernouilli(0.5)",xlab=paste(nnn," times generation"))
plot(simuB2/nbIte,xlim=c(0,nnnBorne),type="b",main = "bernouilli(0.51)",xlab=paste(nnnBorne," times generation"))
plot(simuB3/nbIte,xlim=c(0,nnnSup),type="b",main = "bernouilli(0.7)",xlab=paste(nnnSup," times generation"))
Pour la loi bernouilli, on a essayé de passé la proba superieur à 0.5 mais dans ce ca là, le programme va se bloquer et ne bougera plus, donc on résumerait que pour la loi de bernouilli, la proba borné convergente serait 0.5
par(mfrow = c(1,3))
nnn=1000
nnnBorne = 50
nnnSup = 10
nbIte=30
simuBin1=array(0,nnn)
simuBin2=array(0,nnnBorne)
simuBin3=array(0,nnnSup)
for(i in 1:nbIte){
simuBin1=creer_fils(nnn,0.1,'bin')+simuBin1 #
simuBin2=creer_fils(nnnBorne,0.11,'bin')+simuBin2
simuBin3=creer_fils(nnnSup,0.2,'bin')+simuBin3
# simuGeo=creer_fils(nnn,0.1,'geo')+simuGeo
# simuPoisson=creer_fils(nnn,0.1,'poisson')+simuPoisson
}
print('binomiale')## [1] "binomiale"plot(simuBin1/nbIte,xlim=c(0,nnn),type="b",main="binomiale (0.1)",xlab = paste(nnn," times generation"))
plot(simuBin2/nbIte,xlim=c(0,nnnBorne),type="b",main="binomiale(0.11)",xlab=paste(nnnBorne," times generation"))
plot(simuBin3/nbIte,xlim=c(0,nnnSup),type="b",main="binomiale(0.2)",xlab=paste(nnnSup," times generation"))
# plot(simuGeo/nbIte,xlim=c(0,100),type="b",main="geometric")
# plot(simuPoisson/nbIte,xlim=c(0,100),type="b",main="poisson")Pour la loi de binomiale, on a essayé de passé la proba superieur à 0.1 mais dans ce cas là, le programme va se bloquer et ne pourrait plus s’exécuter dans un temps fini. On résume que pour la loi binomiale, la borne de convergence serait 0.1
par(mfrow = c(1,3))
nnn=1000
nnnBorne=30
nnnSup=10
nbIte=50
simuGeo1=array(0,nnnBorne)
simuGeo2=array(0,nnnSup)
simuGeo3=array(0,nnn)
for(i in 1:nbIte){
simuGeo2=creer_fils(nnnSup,0.3,'geo')+simuGeo2
simuGeo1=creer_fils(nnnBorne,0.49,'geo')+simuGeo1
simuGeo3=creer_fils(nnn,0.5,'geo')+simuGeo3
}
print("geometrique")## [1] "geometrique"plot(simuGeo3/nbIte,xlim=c(0,nnn),type="b",main="Geometric(0.5)",xlab = paste(nnn," times generation"))
plot(simuGeo1/nbIte,xlim=c(0,nnnBorne),type="b",main="Geometric (0.49)",xlab = paste(nnnBorne," times generation"))
plot(simuGeo2/nbIte,xlim=c(0,nnnSup),type="b",main="Geometric(0.3)",xlab = paste(nnnSup," times generation"))
# plot(simuGeo/nbIte,xlim=c(0,100),type="b",main="geometric")
# plot(simuPoisson/nbIte,xlim=c(0,100),type="b",main="poisson")Pour la loi geometric, comme la possibilité de générer k processus est p*(1-p)^(k+1), c-à-dire que le système tend à incrémenter le nombre de fils générés à mesure que la proba s’incrémente et la borne de convergence serait 0.5.
par(mfrow = c(1,3))
nnn=1000
nnnBorne=10
nnnSup=30
nbIte=30
simuPoisson1=array(0,nnnSup)
simuPoisson2=array(0,nnnBorne)
simuPoisson3=array(0,nnn)
for(i in 1:nbIte){
simuPoisson1=creer_fils(nnnSup,1.1,'poisson')+simuPoisson1
simuPoisson2=creer_fils(nnnBorne,2,'poisson')+simuPoisson2
simuPoisson3=creer_fils(nnn,1,'poisson')+simuPoisson3
}
print("Poisson")## [1] "Poisson"plot(simuPoisson3/nbIte,xlim=c(0,nnn),type="b",main="Geometric(0.9)", xlab=paste(nnn," times generation"))
plot(simuPoisson1/nbIte,xlim=c(0,nnnSup),type="b",main="Geometric(1.1)", xlab=paste(nnnSup," times generation"))
plot(simuPoisson2/nbIte,xlim=c(0,nnnBorne),type="b",main="Geometric (1)", xlab=paste(nnnBorne," times generation"))
Pour la loi poisson, sa paramètre λ représente son expérance, donc la probabilité de générer des fils et poursuivre son exécution (donc p0 p1 p2…) se grandi avec la λ plus grand. Le résultat qu’on a observé nous prouve cette hypothèse.
Question 2: Comme les grqphes nous ont démontré, quand le système est stable, le nonbre de processus existants dans le système au temps réel incrémente à un nombre maximal et ensuite se diminueraient jusq’a 0. C-à-dire que les processus se termineront à fur et mesure donc la forme de l’arbre de génération se ressemble un fuseau donc à un moment la largeur de l’arbre attaint au maxmum et ensuite il y a des processus ne produiront plus des fils et eux-même se forment les feuilles de l’arbre. A la fin, il n’existe plus des processus et l’arbre atteit sa profondeur maximale.