): #El sifon vacio en deadlock esta vacio en idle?
flag_sifon_idle = 1
if (flag_sifon_idle == 0): #El sifon no estaba vacio en idle
sifon_deadlock.append(
[estado, i, marcado]
) #Devuelve el sifon y su marcado inicial, para ese estado deadlock
else:
sifon_idle.append(i)
#Conversion de archivos html a txt
hta.main()
#Filtrado de archivos provenientes del Petrinator
(cantidad_estados, cantidad_plazas, cantidad_transiciones, matriz_es_tr,
matriz_es_pl, state_deadlock) = filterdata.main()
#Matrices
(matriz_sifones, matriz_traps, cantidad_sifones,
cantidad_traps) = siphones_traps(cantidad_plazas)
(matriz_pos, matriz_pre) = matriz_pre_pos(cantidad_plazas,
cantidad_transiciones)
#T-invariantes
t_invariant = invariantes(cantidad_transiciones)
sifon_idle = [] #Estado_idle sifon
sifon_deadlock = [] #Estado_deadlock-sifon-marcado
idle = 1 #Sifones vacios estado inicial
def main():
print(
"--------------------------------------------------------------------------"
)
print(
"Algoritmo para la solucion de deadlock para redes de petri tipo S3PR")
print(
"--------------------------------------------------------------------------"
)
#Conversion de archivos html a txt
hta.main()
#Filtrado de archivos provenientes del Petrinator
(cantidad_estados, cantidad_plazas, cantidad_transiciones, matriz_es_tr,
matriz_es_pl, state_deadlock) = filterdata.main()
#Matrices
(matriz_sifones, matriz_traps, cantidad_sifones,
cantidad_traps) = siphones_traps(cantidad_plazas)
(matriz_pos, matriz_pre) = matriz_pre_pos(cantidad_plazas,
cantidad_transiciones)
#T-invariantes
t_invariant = invariantes(cantidad_transiciones)
print("\nIngrese: ")
print("1 - Primer analisis de la red")
print("2 - Segundo analisis analisis de la red")
print("3 - Red con supervisores, tratamiento de conflicto y t_idle")
#print("4 - Red con supervisores y tratamiento de t_idle")
analisis = input("\nOpcion: ")
print("\n")
#analisis= input("Primer analisis de la red -> 1\nSub red de la red original ->2\n Red con supervisores y tratamiento de conflicto -> 3\nRed con supervisores y tratamiento de t_idles -> 4")
if (analisis == "1"):
#Obtenemos la cantidad de plazas de la red original
file_plazas = open('cantidad_plazas_red_original.txt', 'w')
file_plazas.write(str(len(matriz_es_pl[0])))
file_plazas.close()
#Guardamos los T-invariantes de la red original
file_t_inv_orig = open('invariante_red_original.txt', 'w')
for i in range(0, len(t_invariant)):
for j in range(0, len(t_invariant[0])):
file_t_inv_orig.write(str(t_invariant[i][j]) + ' ')
file_t_inv_orig.write("\n")
file_t_inv_orig.close()
if (analisis == "2" or analisis == "1"):
sifon_idle = [] #Estado_idle sifon
sifon_deadlock = [] #Estado_deadlock-sifon-marcado
idle = 1 #Sifones vacios estado inicial
fun_sifones_deadlock(0, matriz_sifones, matriz_es_pl, idle,
cantidad_plazas, cantidad_sifones, sifon_idle,
sifon_deadlock)
print("Sifones vacios en idle", sifon_idle)
#Llamada recursiva a fun_deadlock en busqueda de caminos que dirigen al deadlock
idle = 0 #Sifones en estado deadlock
for i in range(0, len(state_deadlock)):
fun_sifones_deadlock(state_deadlock[i], matriz_sifones,
matriz_es_pl, idle, cantidad_plazas,
cantidad_sifones, sifon_idle, sifon_deadlock)
print("Estados con deadlock", state_deadlock)
print("Cantidad de estados con deadlock", len(state_deadlock))
print("Estado deadlock, sifon asociado al deadlock y su marcado",
sifon_deadlock)
print("Cantidad de sifones vacios:", len(sifon_deadlock))
###################################
### ESTO SOLUCIONABA LO DE INANICION SI SIRVE INCLUIR
#sifones_not_bad=np.zeros(len(matriz_sifones)) #Todos los que tengan 0 son bad siphon
# for ii in range (0, len(matriz_traps)):
# for kk in range(0,len(matriz_sifones)):
# indice_plazas=0
# for jj in range (0,cantidad_plazas):
# if(matriz_traps[ii][jj]==1):
# if(matriz_sifones[kk][jj]==1):
# indice_plazas=indice_plazas+1
# if(indice_plazas==np.sum(matriz_traps[ii])):
# sifones_not_bad[kk]=1
# #print(sifones_not_bad)
# for i in range(0, len(sifones_not_bad)):
# flag=0
# if(sifones_not_bad[i]==0): #Es un bad siphon
# for j in range(0, len(sifon_deadlock)):
# if(flag!=1):
# if(i==sifon_deadlock[j][1]): #Este bad siphon se vacia en deadlock? No hace falta agregarlo ya lo tenemos, en caso de no tenerlo agregarlo para controlarlo
# flag=1
# if(flag==0): #No estaba incluido antes
# marcado=0
# for j in range(0,cantidad_plazas):
# if(matriz_sifones[i][j]==1):
# marcado=marcado+matriz_es_pl[0][j] #Es 0 en fila, porque es el estado inicial en el que se encontraban las plazas de los sifones
# if(marcado!=0):
# sifon_deadlock.append([-1,i,marcado]) #El -1 indica que no es deadlock si no que es inanicion
# print(sifon_deadlock)
##################################################
listita = []
for i in range(0, len(sifon_deadlock)):
#Nos quedamos con un solo sifon
flag = 0
for j in range(0, len(listita)):
if (sifon_deadlock[i][1] == listita[j]):
flag = 1
if (flag == 0):
listita.append(sifon_deadlock[i][1])
print('\n')
sifon = np.copy(sifon_deadlock[i])
#Agregamos el supervisor del bad-sifon
supervisor(cantidad_transiciones, cantidad_plazas, sifon,
matriz_es_tr, matriz_pos, matriz_pre, matriz_sifones,
t_invariant)
print("sifones vacios sin repetir", listita)
print("Cantidad de sifones vacios sin repetir", len(listita))
#Elimina archivo temporal
os.remove("filtrado_prueba.txt")
elif (
analisis == "3"
): #se obtienen los supervisores (3) o Anular brazos de idle a supervisores (4)
file_plazas = open('cantidad_plazas_red_original.txt', 'r')
cantidad_plazas_red_original = int(file_plazas.read())
# print(cantidad_plazas_red_original)
# print(len(matriz_es_pl[0]))
array_supervisor = []
for i in range(cantidad_plazas_red_original, len(matriz_es_pl[0])):
array_supervisor.append(i)
#print(array_supervisor)
trans_idle = [] #Transiciones habilitadas en el marcado inicial
#Transiciones que salen del estado idle
for ii in range(cantidad_transiciones):
if (matriz_es_tr[0][ii] != -1):
trans_idle.append(ii)
#print("Transicion Idle: ",ii+1) #+1 Por problemas de indice en petrinator empieza en 0
#Guardamos los T-invariantes de la red original
file_t_invariant_red_original = open("./invariante_red_original.txt",
"r")
t_invariant_red_original = np.loadtxt(file_t_invariant_red_original,
delimiter=' '
' ',
skiprows=0,
max_rows=cantidad_transiciones,
dtype=bytes).astype(str)
aux_t_inv = []
for i in range(len(t_invariant_red_original)):
aux_t_inv.append(t_invariant_red_original[i].split(" "))
aux_t_inv = np.delete(aux_t_inv, cantidad_transiciones, 1)
t_invariant_red_original = aux_t_inv
#print(t_invariant_red_original)
#Guardamos los conflictos de la red original
file_t_conflict_red_original = open("./t_conflict_red_original.txt",
"r")
t_conflict_red_original = np.loadtxt(file_t_conflict_red_original,
delimiter=' ',
skiprows=0,
max_rows=1,
dtype=bytes).astype(str)
aux_conflic = []
for i in range(len(t_conflict_red_original)):
if (t_conflict_red_original[i] != ""):
aux_conflic.append(t_conflict_red_original[i].split(" "))
t_conflict_red_original = aux_conflic
#print(t_conflict_red_original)
#if(analisis=="3"):
# #Buscamos los T-invariantes en los que esta presenta la transicion en conflictos
# #lo recorremos sin tener en cuenta la T-idle dado que esta afecta a todos los supervisores
# #todo aquel supervisor que no afecte el camino del T-invariante la T-conflicto le debe dar token
# for i in range(len(t_conflict_red_original)):
# aux = int(t_conflict_red_original[i][0])
# for j in range(len(t_invariant_red_original)): #cantidad de t-invariantes
# if(int(t_invariant_red_original[j][aux])==1): #La transicion en conflicto forma parte del T-invariantes
# for m in range(len(array_supervisor)):
# contador=0 #Para verificar si alguna transicion del T-invariante le devuelve al supervisor
# for k in range(len(t_invariant_red_original[j])): #Cantidad de transiciones del t-invariante
# if(int(t_invariant_red_original[j][k])==1):
# if(int(matriz_pos[array_supervisor[m]][k])==1): #Le devuelve token al supervisores
# contador = contador + 1
# #print("Supervisor ",array_supervisor[m]+1, " Contador ",contador)
# if(contador==0):
# print("La transicion en conflicto ", aux+1," le tiene que devolver un token al supervisor ", array_supervisor[m]+1)
# else:
#Buscamos eliminar los arcos de las transiciones idle cuyo T-invariante al que pertenece no le devuelve token al supervisor. (i.e arcos innecesarios)
for i in range(len(trans_idle)): #Cantidad de trans_idle
for j in range(
len(t_invariant_red_original)): #cantidad de t-invariantes
if (int(t_invariant_red_original[j][trans_idle[i]]) == 1
): #La transicion idle forma parte del t-invariantes
for m in range(len(array_supervisor)):
cont_sup = 0
for l in range(len(t_invariant_red_original[j])):
if (int(t_invariant_red_original[j][l]) == 1):
if (
int(matriz_pos[array_supervisor[m]]
[l]) == 1
): #El T-invariante de la transicion idle le devuelve token al supervisor?
cont_sup = 1 # si devuelve
if (cont_sup == 0): #no devuelve
cont = 0
for k in range(len(t_conflict_red_original)):
aux = int(t_conflict_red_original[k][0])
if (
int(t_invariant_red_original[j]
[aux]) == 1
): #La transicion en conflicto forma parte del T-invariante
cont = cont + 1
print(
"La transicion en conflicto ", aux + 1,
" le tiene que devolver un token al supervisor ",
array_supervisor[m] + 1)
if (cont == 0):
if (int(matriz_pre[int(
array_supervisor[m])][int(
trans_idle[i])]) == 1):
print("Eliminar arco desde ",
array_supervisor[m] + 1, "hasta ",
trans_idle[i] + 1)
else:
print("Opcion erronea")
exit()
np.save('./data/' + date + '.npy', population)
def all_data(date_list, node):
for date in date_list:
print(str(date)[:10])
data_single_day(str(date)[:10], node)
print("Finish!")
def concatenate(date_list, node):
data = []
for date in date_list:
if str(date)[:10] == "2018-09-28":
continue
if date.weekday() >= 5:
continue
tmp = np.load("./data/" + str(date)[:10] + '.npy')
data.append(tmp.reshape(24, len(node)))
return np.array(data)
for date in date_generated:
Recover.re(str(date)[0:10])
for date in date_generated:
filter_data.main(str(date)[0:10])
all_data(date_list=['2018-10-04'], node=node)
#data = concatenate(date_list=date_generated, node=node)
def main():
print(
"--------------------------------------------------------------------------"
)
print(
"Algoritmo para la solucion de deadlock para redes de petri tipo S3PR")
print(
"--------------------------------------------------------------------------"
)
#Conversion de archivos html a txt
hta.main()
#Filtrado de archivos provenientes del Petrinator
(cantidad_estados, cantidad_plazas, cantidad_transiciones, matriz_es_tr,
matriz_es_pl, state_deadlock) = filterdata.main()
#Matrices
(matriz_sifones, matriz_traps, cantidad_sifones,
cantidad_traps) = siphones_traps(cantidad_plazas)
(matriz_pos, matriz_pre) = matriz_pre_pos(cantidad_plazas,
cantidad_transiciones)
#T-invariantes
t_invariant = invariantes(cantidad_transiciones)
print("\nIngrese: ")
print("1 - Primer analisis de la red")
print("2 - Análisis de red con supervisores")
print("3 - Red con supervisores, tratamiento de conflicto y t_idle")
analisis = input("\nOpcion: ")
print("\n")
#analisis= input("Primer analisis de la red -> 1\nSub red de la red original ->2\n Red con supervisores y tratamiento de conflicto -> 3\nRed con supervisores y tratamiento de t_idles -> 4")
if (analisis == "1"):
#Obtenemos la cantidad de plazas de la red original
file_plazas = open('cantidad_plazas_red_original.txt', 'w')
file_plazas.write(str(len(matriz_es_pl[0])))
file_plazas.close()
#Guardamos los T-invariantes de la red original
file_t_inv_orig = open('invariante_red_original.txt', 'w')
for i in range(0, len(t_invariant)):
for j in range(0, len(t_invariant[0])):
file_t_inv_orig.write(str(t_invariant[i][j]) + ' ')
file_t_inv_orig.write("\n")
file_t_inv_orig.close()
global name_pflow
name_pflow = input("Ingrese el nombre de la red(.pflow): ")
if (analisis == "2" or analisis == "1"):
sifon_idle = [] #Estado_idle sifon
sifon_deadlock = [] #Estado_deadlock-sifon-marcado
idle = 1 #Sifones vacios estado inicial
fun_sifones_deadlock(0, matriz_sifones, matriz_es_pl, idle,
cantidad_plazas, cantidad_sifones, sifon_idle,
sifon_deadlock)
print("Sifones vacios en idle", sifon_idle)
#Llamada recursiva a fun_deadlock en busqueda de caminos que dirigen al deadlock
idle = 0 #Sifones en estado deadlock
for i in range(0, len(state_deadlock)):
fun_sifones_deadlock(state_deadlock[i], matriz_sifones,
matriz_es_pl, idle, cantidad_plazas,
cantidad_sifones, sifon_idle, sifon_deadlock)
#print("Estados con deadlock",state_deadlock)
print("Cantidad de estados con deadlock:", len(state_deadlock))
#print("Estado deadlock, sifon asociado al deadlock y su marcado",sifon_deadlock)
print("Cantidad de sifones vacios:", len(sifon_deadlock))
lista_supervisores = []
for i in range(0, len(sifon_deadlock)):
#Nos quedamos con un solo sifon
sifon = np.copy(sifon_deadlock[i])
#Agregamos el supervisor del bad-sifon
supervisor(cantidad_transiciones, cantidad_plazas, sifon,
matriz_es_tr, matriz_pos, matriz_pre, matriz_sifones,
t_invariant, lista_supervisores)
#Elimina archivo temporal
os.remove("filtrado_prueba.txt")
elif (
analisis == "3"
): #se obtienen los supervisores (3) o Anular brazos de idle a supervisores (4)
file_plazas = open('cantidad_plazas_red_original.txt', 'r')
cantidad_plazas_red_original = int(file_plazas.read())
array_supervisor = []
for i in range(cantidad_plazas_red_original, len(matriz_es_pl[0])):
array_supervisor.append(i)
trans_idle = [] #Transiciones habilitadas en el marcado inicial
#Transiciones que salen del estado idle
for ii in range(cantidad_transiciones):
if (matriz_es_tr[0][ii] != -1):
trans_idle.append(ii)
#Guardamos los T-invariantes de la red original
file_t_invariant_red_original = open("./invariante_red_original.txt",
"r")
t_invariant_red_original = np.loadtxt(file_t_invariant_red_original,
delimiter=' '
' ',
skiprows=0,
max_rows=cantidad_transiciones,
dtype=bytes).astype(str)
aux_t_inv = []
for i in range(len(t_invariant_red_original)):
aux_t_inv.append(t_invariant_red_original[i].split(" "))
aux_t_inv = np.delete(aux_t_inv, cantidad_transiciones, 1)
t_invariant_red_original = aux_t_inv
#Guardamos los conflictos de la red original
file_t_conflict_red_original = open("./t_conflict_red_original.txt",
"r")
t_conflict_red_original = np.loadtxt(file_t_conflict_red_original,
delimiter=' ',
skiprows=0,
max_rows=1,
dtype=bytes).astype(str)
aux_conflic = []
for i in range(len(t_conflict_red_original)):
if (t_conflict_red_original[i] != ""):
aux_conflic.append(t_conflict_red_original[i].split(" "))
t_conflict_red_original = aux_conflic
#Buscamos eliminar los arcos de las transiciones idle cuyo T-invariante al que pertenece no le devuelve token al supervisor. (i.e arcos innecesarios)
for i in range(len(trans_idle)): #Cantidad de trans_idle
for j in range(
len(t_invariant_red_original)): #cantidad de t-invariantes
if (int(t_invariant_red_original[j][trans_idle[i]]) == 1
): #La transicion idle forma parte del t-invariantes
for m in range(len(array_supervisor)):
cont_sup = 0
for l in range(len(t_invariant_red_original[j])):
if (int(t_invariant_red_original[j][l]) == 1):
if (
int(matriz_pos[array_supervisor[m]]
[l]) == 1
): #El T-invariante de la transicion idle le devuelve token al supervisor?
cont_sup = 1 # si devuelve
if (cont_sup == 0): #no devuelve
cont = 0
for k in range(len(t_conflict_red_original)):
aux = int(t_conflict_red_original[k][0])
if (
int(t_invariant_red_original[j]
[aux]) == 1
): #La transicion en conflicto forma parte del T-invariante
cont = cont + 1
print(
"La transicion en conflicto ", aux + 1,
" le tiene que devolver un token al supervisor ",
array_supervisor[m] + 1)
if (cont == 0):
if (int(matriz_pre[int(
array_supervisor[m])][int(
trans_idle[i])]) == 1):
print("Eliminar arco desde ",
array_supervisor[m] + 1, "hasta ",
trans_idle[i] + 1)
else:
print("Opcion erronea")
exit()
decision = ""
if (analisis != "3"):
decision = input("\n¿Agregar supervisor?(S/N) ").upper()
if (decision == "S"):
id_int = int(input("AGREGA EL ID: "))
new_red.main(lista_supervisores[id_int][0],
lista_supervisores[id_int][1],
lista_supervisores[id_int][2],
lista_supervisores[id_int][3], name_pflow)
def main():
#print("--------------------------------------------------------------------------")
#print("Algoritmo para la solucion de deadlock para redes de petri tipo S3PR")
#print("--------------------------------------------------------------------------")
#obetnemos primer argumento del socket
length_of_message = int.from_bytes(sCliente.recv(2), byteorder='big')
analisis = sCliente.recv(length_of_message).decode("UTF-8")
#Conversion de archivos html a txt
error = False
try:
hta.main()
#Filtrado de archivos provenientes del Petrinator
(cantidad_estados, cantidad_plazas , cantidad_transiciones, matriz_es_tr, matriz_es_pl, state_deadlock) = filterdata.main()
#Matrices
(matriz_sifones,matriz_traps,cantidad_sifones,cantidad_traps)=siphones_traps(cantidad_plazas)
(matriz_pos,matriz_pre)=matriz_pre_pos(cantidad_plazas,cantidad_transiciones)
#T-invariantes
t_invariant=invariantes(cantidad_transiciones)
print("\nIngrese: ")
print("1 - Primer analisis de la red")
print("2 - Análisis de red con supervisores")
print("3 - Red con supervisores, tratamiento de conflicto y t_idle")
if (analisis == "quit"):
closeSocket()
if(analisis=="1"):
#Obtenemos la cantidad de plazas de la red original
file_plazas = open(Jar_path + '/tmp/cantidad_plazas_red_original.txt', 'w')
file_plazas.write(str(len(matriz_es_pl[0])))
file_plazas.close()
#Guardamos los T-invariantes de la red original
file_t_inv_orig = open(Jar_path + '/tmp/invariante_red_original.txt', 'w')
for i in range (0, len(t_invariant)):
for j in range(0, len(t_invariant[0])):
file_t_inv_orig.write(str(t_invariant[i][j]) + ' ')
file_t_inv_orig.write("\n")
file_t_inv_orig.close()
print("\n")
file_t_conflict_orig = open(Jar_path + '/tmp/t_conflict_red_original.txt', 'w')
file_t_conflict_orig.close()
if(analisis=="2" or analisis=="1" or analisis == "S"):#entro en la opcion S para obtener: sifon_deadlock
sifon_idle=[] #Estado_idle sifon
sifon_deadlock=[] #Estado_deadlock-sifon-marcado
idle=1 #Sifones vacios estado inicial
fun_sifones_deadlock(0,matriz_sifones,matriz_es_pl,idle,cantidad_plazas,cantidad_sifones,sifon_idle,sifon_deadlock)
#print("Sifones vacios en idle",sifon_idle)
#Llamada recursiva a fun_deadlock en busqueda de caminos que dirigen al deadlock
idle=0 #Sifones en estado deadlock
for i in range (0, len(state_deadlock)):
fun_sifones_deadlock(state_deadlock[i],matriz_sifones,matriz_es_pl,idle,cantidad_plazas,cantidad_sifones,sifon_idle,sifon_deadlock)
print("Cantidad de estados con deadlock:", len(state_deadlock))
respuesta = "Cantidad de estados con deadlock: "+ str(len(state_deadlock)) +"<br>"
print("Cantidad de sifones vacios:", len(sifon_deadlock))
respuesta += "Cantidad de sifones vacios: "+ str(len(sifon_deadlock)) +"<br>"
lista_supervisores=[]
for i in range(0, len(sifon_deadlock)):
#Nos quedamos con un solo sifon
sifon=np.copy(sifon_deadlock[i])
#Agregamos el supervisor del bad-sifon
respuesta +=supervisor(cantidad_transiciones,cantidad_plazas,sifon,matriz_es_tr,matriz_pos,matriz_pre,matriz_sifones,t_invariant,lista_supervisores)
#Elimina archivo temporal
os.remove("filtrado_prueba.txt")
#respuesta
if(analisis=="S"):
respuesta = createString(len(sifon_deadlock))#le envio la cantidad de sifones
respuesta = respuesta.encode("UTF-8")
sCliente.send(len(respuesta).to_bytes(2, byteorder='big'))
sCliente.send(respuesta)
#espero un ID
length_of_message = int.from_bytes(sCliente.recv(2), byteorder='big')
recv=sCliente.recv(length_of_message).decode("UTF-8")
if(recv=="quit"):
closeSocket()
id_int = int(recv)
#id_int= 0 #int(input("AGREGA EL ID: "))
new_red.main(lista_supervisores[id_int][0],lista_supervisores[id_int][1],lista_supervisores[id_int][2],lista_supervisores[id_int][3],Pflow_path)
#nuevo
respuesta = "Se agrego el supervisor id: " + recv
if(analisis=="3"): #se obtienen los supervisores (3) o Anular brazos de idle a supervisores (4)
file_plazas = open(Jar_path + '/tmp/cantidad_plazas_red_original.txt', 'r')
cantidad_plazas_red_original=int(file_plazas.read())
array_supervisor =[]
for i in range (cantidad_plazas_red_original,len(matriz_es_pl[0])):
array_supervisor.append(i)
trans_idle=[] #Transiciones habilitadas en el marcado inicial
#Transiciones que salen del estado idle
for ii in range(cantidad_transiciones):
if(matriz_es_tr[0][ii]!=-1):
trans_idle.append(ii)
#Guardamos los T-invariantes de la red original
file_t_invariant_red_original = open(Jar_path + "/tmp/invariante_red_original.txt","r")
t_invariant_red_original = []
aux_t_inv = []
for line in file_t_invariant_red_original:
aux_t_inv.append(line)
for i in range(len(aux_t_inv)):
t_invariant_red_original.append(str(aux_t_inv[i]).split())
#Guardamos los conflictos de la red original
file_t_conflict_red_original = open(Jar_path + "/tmp/t_conflict_red_original.txt","r")
t_conflict_red_original = []
t_conflict_red_original_aux = []
aux_conflic = []
for line in file_t_conflict_red_original:
aux_conflic.append(line)
for i in range(len(aux_conflic)):
t_conflict_red_original_aux.append(str(aux_conflic[i]).split())
if(len(t_conflict_red_original_aux)!=0):
t_conflict_red_original = t_conflict_red_original_aux[0]
msjadd = []
msjdel = []
#Buscamos eliminar los arcos de las transiciones idle cuyo T-invariante al que pertenece no le devuelve token al supervisor. (i.e arcos innecesarios)
for i in range(len(trans_idle)): #Cantidad de trans_idle
for j in range(len(t_invariant_red_original)): #cantidad de t-invariantes
if(int(t_invariant_red_original[j][trans_idle[i]])==1): #La transicion idle forma parte del t-invariantes
for m in range(len(array_supervisor)):
cont_sup = 0
for l in range(len(t_invariant_red_original[j])):
if(int(t_invariant_red_original[j][l])==1):
if(int(matriz_pos[array_supervisor[m]][l])==1): #El T-invariante de la transicion idle le devuelve token al supervisor?
cont_sup = 1 # si devuelve
if(cont_sup==0): #no devuelve
cont=0
for k in range(len(t_conflict_red_original)):
aux = int(t_conflict_red_original[k])
if(int(t_invariant_red_original[j][aux])==1): #La transicion en conflicto forma parte del T-invariante por lo tanto debe devolver el token
cont = cont + 1
print(f"La transicion en conflicto T{aux+1} le tiene que devolver un token al supervisor P{array_supervisor[m]+1}")
msjadd.append('Se agrego un arco desde '+ str(f'T{aux+1}') + ' hasta ' + str(f'P{array_supervisor[m]+1}'))
#Se agrega el arco
arcosrdp.agregararco(Pflow_path,aux+1,array_supervisor[m]+1)
if(cont == 0):
if(int(matriz_pre[int(array_supervisor[m])][int(trans_idle[i])])==1):
print(f"Eliminar arco desde P{array_supervisor[m]+1} hasta T{trans_idle[i]+1}")
msjdel.append('Se elimino el arco desde '+ str(f'P{array_supervisor[m]+1}') + ' hasta ' + str(f'T{trans_idle[i]+1}'))
#Se elimina el arco
arcosrdp.eliminararco(Pflow_path, array_supervisor[m]+1, trans_idle[i]+1)
respuesta=""
print("\n")
for i in range (len(msjadd)):
print(msjadd[i])
respuesta+=msjadd[i]+"<br>"
for i in range (len(msjdel)):
print(msjdel[i])
respuesta+=msjdel[i]+"<br>"
if (respuesta==""):
respuesta="No hay conflictos<br>"
#aca llegamos luego del addsupervisor en espera de saber si hay deadlock o no para continuar el analisis
# length_of_message = int.from_bytes(sCliente.recv(2), byteorder='big')
# decision = sCliente.recv(length_of_message).decode("UTF-8")
except Exception as e:
error = True
respuesta = "Error : " + str(e) + " occurred."
print(respuesta)
#ENVIO INFO AL SOCKET
respuesta =respuesta.encode("UTF-8")
sCliente.send(len(respuesta).to_bytes(2, byteorder='big'))
sCliente.send(respuesta)
if(error):
cleanTXTS()
sCliente.close()
exit(0)
flag_sifon_idle=1
if(flag_sifon_idle==0): #El sifon no estaba vacio en idle
sifon_deadlock.append([estado,i,marcado]) #Devuelve el sifon y su marcado inicial, para ese estado deadlock
else:
sifon_idle.append(i)
print("--------------------------------------------------------------------------")
print("Algoritmo para la solucion de deadlock para redes de Petri tipo S3PR")
print("--------------------------------------------------------------------------")
#Conversion de archivos html a txt
hta.main()
#Filtrado de archivos provenientes del Petrinator
(cantidad_estados, cantidad_plazas , cantidad_transiciones, matriz_es_tr, matriz_es_pl, state_deadlock) = filterdata.main()
#Matrices
(matriz_sifones,matriz_traps,cantidad_sifones,cantidad_traps)=siphones_traps(cantidad_plazas)
(matriz_pos,matriz_pre)=matriz_pre_pos(cantidad_plazas,cantidad_transiciones)
#T-invariantes
t_invariant=invariantes(cantidad_transiciones)
sifon_idle=[] #Estado_idle sifon
sifon_deadlock=[] #Estado_deadlock-sifon-marcado
idle=1 #Sifones vacios estado inicial
fun_sifones_deadlock(0,matriz_sifones,matriz_es_pl,idle)
