-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathrun1.py
More file actions
178 lines (159 loc) · 5.71 KB
/
run1.py
File metadata and controls
178 lines (159 loc) · 5.71 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
# 随机可信中继，随机拓扑，随机请求 节点安全概率
from alg.Topo import *
from alg.Net import *
from alg.Alg1 import *
from alg.RandomRouting import *
from alg.Alg2 import *
from alg.Securitylevel import *
from alg.consume import *
import copy, random, time
import matplotlib.pyplot as plt
import numpy as np
def doRun1(run_time=100, a=0.3, b=3, nodenum=50, trnum=5):
filename = (
"MaxSp_vs_NodeSp"
+ str(run_time)
+ "trnum="
+ str(trnum)
+ "a="
+ str(a)
+ "b="
+ str(b)
+ "nodenum="
+ str(nodenum)
+ ".txt"
)
fp = open(filename, "w")
fp.write(
"NodeSp aveMaxSp_random aveMaxSp_sgr 资源利用率_random 资源利用率_sgr 重构0.9后密钥量_random 重构0.9后密钥量_sgr 重构0.7后密钥量_random 重构0.7后密钥量_sgr 重构0.5后密钥量_random 重构0.5后密钥量_sgr\n"
)
node_sp = np.arange(0.5, 1, 0.05)
# 最大安全性
avemaxsp_random = [0] * len(node_sp)
avemaxsp_sgr = [0] * len(node_sp)
# 资源利用率
resource_consume_random = [0] * len(node_sp)
resource_consume_sgr = [0] * len(node_sp)
# 重构后密钥量0.9
keynum_9_random = [0] * len(node_sp)
keynum_9_sgr = [0] * len(node_sp)
keynum_7_random = [0] * len(node_sp)
keynum_7_sgr = [0] * len(node_sp)
keynum_5_random = [0] * len(node_sp)
keynum_5_sgr = [0] * len(node_sp)
# 记录分段的次数
segnum = [0] * len(node_sp)
start_time = time.time()
start_time = time.time()
for count in range(run_time):
print("running:", count, "round")
if count != 0:
print(
"预计剩余时间为：",
(time.time() - start_time) * (run_time - count) / count / 60,
"min",
)
random_topo = Topo().create_random_topology(
nodenum, a, b
) # 随机拓扑生成：点边集合
NodeEdgeSet = Topo().CreatNodeEdgeSet(random_topo, 10, trnum, 0.8)
topo = Topo().CreatTopo(NodeEdgeSet)
source = random.randint(0, len(topo[0]) - 1)
des = random.randint(0, len(topo[0]) - 1)
while des == source:
des = random.randint(0, len(topo[0]) - 1)
for j in range(len(node_sp)):
# 更改节点安全概率
for t in range(len(topo[1])):
if topo[1][t] != 1:
topo[1][t] = node_sp[j]
# 算法运行
print("节点安全概率：", node_sp[j])
tr = Rr().rrmaxs(copy.deepcopy(topo), source, des)
print(tr)
avemaxsp_random[j] += tr[0][2]
resource_consume_random[j] += Con().CalCon(tr) * 2 / len(random_topo[1])
keynum_9_random[j] += Seclev().sl(tr, 0.9)
keynum_7_random[j] += Seclev().sl(tr, 0.7)
keynum_5_random[j] += Seclev().sl(tr, 0.5)
t2 = Alg2().alg2max(copy.deepcopy(topo), source, des)
print(t2)
if len(t2) > 1:
segnum[j] += 1
totalsp = 1
for i in t2:
totalsp *= i[2]
avemaxsp_sgr[j] += totalsp
resource_consume_sgr[j] += Con().CalCon(t2) * 2 / len(random_topo[1])
keynum_9_sgr[j] += Seclev().sl(t2, 0.9)
keynum_7_sgr[j] += Seclev().sl(t2, 0.7)
keynum_5_sgr[j] += Seclev().sl(t2, 0.5)
for j in range(len(node_sp)):
avemaxsp_random[j] /= run_time
avemaxsp_sgr[j] /= run_time
resource_consume_random[j] /= run_time
resource_consume_sgr[j] /= run_time
keynum_9_random[j] /= run_time
keynum_9_sgr[j] /= run_time
keynum_7_random[j] /= run_time
keynum_7_sgr[j] /= run_time
keynum_5_random[j] /= run_time
keynum_5_sgr[j] /= run_time
for j in range(len(node_sp)):
fp.write(
str(node_sp[j])
+ " "
+ str(avemaxsp_random[j])
+ " "
+ str(avemaxsp_sgr[j])
+ " "
+ str(resource_consume_random[j])
+ " "
+ str(resource_consume_sgr[j])
+ " "
+ str(keynum_9_random[j])
+ " "
+ str(keynum_9_sgr[j])
+ " "
+ str(keynum_7_random[j])
+ " "
+ str(keynum_7_sgr[j])
+ " "
+ str(keynum_5_random[j])
+ " "
+ str(keynum_5_sgr[j])
+ "\n"
)
for j in segnum:
fp.write(str(j) + " ")
fp.close()
# 最大安全概率
fig = plt.figure()
plt.plot(node_sp, avemaxsp_random, color="red")
plt.plot(node_sp, avemaxsp_sgr, color="green")
plt.title("Max Security probability")
plt.xlabel("nodesp")
plt.ylabel("max Security probability")
plt.savefig("max_security_probability1.png")
# 资源利用率
fig = plt.figure()
plt.plot(node_sp, resource_consume_random, color="red")
plt.plot(node_sp, resource_consume_sgr, color="green")
plt.title("Resource utilization")
plt.xlabel("nodesp")
plt.ylabel("Resource utilization")
plt.savefig("resource_utilization1.png")
# 不同安全概率阈值下的密钥分发速率
fig = plt.figure()
plt.plot(node_sp, keynum_9_random, color="red")
plt.plot(node_sp, keynum_9_sgr, color="green")
plt.plot(node_sp, keynum_7_random, color="red")
plt.plot(node_sp, keynum_7_sgr, color="green")
plt.plot(node_sp, keynum_5_random, color="red")
plt.plot(node_sp, keynum_5_sgr, color="green")
plt.title("Key rate")
plt.xlabel("nodesp")
plt.ylabel("Key rate")
plt.savefig("key_rate1.png")
if __name__ == "__main__":
doRun1()