3680947894

Build Type

github

Committed by GitHub

Commit Message

Merge a6cd61918 into b40be3bdd

Pull Request Pull Request #81: Updates coveralls.io configuration

Run Details

845 of 1796 relevant lines covered (47.05%)

0.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Utility/Benchmarking.py

import json

import matplotlib.pyplot as plt
import numpy as np

from LoadBalancing.MC_Solver import runMC_Solver
from LoadBalancing.RandomTopologyGenerator import lbnxgraphgenerator


def filesave(file):
    with open("../test/data/graphdata2.json", "w") as json_file:
        json.dump(file, json_file, indent=4)


def draw_errorbar(nodes, avglist, std, name):
    labels = []
    x_axis = []
    for num in range(nodes[0], nodes[1]):
        labels.append(str(num))
        x_axis.append(num)

    x_pos = np.arange(len(labels))
    fig, ax = plt.subplots()
    ax.bar(
        x_pos, avglist, yerr=std, align="center", alpha=0.5, ecolor="black", capsize=10
    )

    ax.set_xticks(x_pos)
    ax.set_xticklabels(labels)
    ax.set_title(name)
    ax.yaxis.grid(True)
    ax.set_xlabel("Number of Nodes")
    ax.set_ylabel("Path Weights")

    plt.tight_layout()
    plt.savefig("Heuristic Std Error.png", dpi=300)
    plt.show()


def draw_comparisiontime(
    nodes, solvertimelist, heurtimelist_latency, heurtimelist_weight
):
    labels = []
    x_axis = []
    for num in range(nodes[0], nodes[1]):
        labels.append(str(num))
        x_axis.append(num)

    plt.plot(x_axis, solvertimelist, label="solver")
    plt.plot(x_axis, heurtimelist_latency, label="latency")
    plt.plot(x_axis, heurtimelist_weight, label="weight")
    plt.xlabel("Number of Nodes")
    plt.ylabel("Milliseconds")
    plt.title("Computation Time: Solver Vs Heuristic")
    plt.legend()
    plt.savefig("Computatoin Time", dpi=300)
    plt.show()


def draw_weightcomparison(
    nodes, heuravglist_latency, heuravglist_weight, solveravglist
):

    Y = heuravglist_latency
    Z = solveravglist
    W = heuravglist_weight

    X = list(range(nodes[0], nodes[1]))

    X_axis = np.arange(len(X))
    width = 0.25

    plt.bar(X_axis, Y, width, label="Latency Solution")
    plt.bar(X_axis + width, W, width, label="Weight Solution")
    plt.bar(X_axis + 2 * width, Z, width, label="Solver Solution")

    plt.xticks(X_axis, X)
    plt.xlabel("Nodes")
    plt.ylabel("NWeights")
    plt.title("Heuristic VS Solver (Sorted by latency)")
    plt.legend()
    plt.savefig("Weights comparision.png", dpi=300)
    plt.show()


def draw_errorplotweightplot(
    nodes,
    heuravglist_latency,
    heurstd_latency,
    heuravglist_weight,
    heurstd_weight,
    solveravglist,
    solstd,
):
    W = heuravglist_weight
    Y = heuravglist_latency
    Z = solveravglist
    Yerr = heurstd_latency
    Zerr = solstd
    Werr = heurstd_weight

    x_axis = np.linspace(nodes[0], nodes[1] - 1, nodes[1] - nodes[0])

    fig, ax = plt.subplots()

    ax.errorbar(x_axis, W, yerr=Werr, fmt="-o", label="weight")
    ax.errorbar(x_axis, Y, yerr=Yerr, fmt="-o", label="Latency")
    ax.errorbar(x_axis, Z, yerr=Zerr, fmt="-o", label="Solver")

    ax.set_xlabel("Nodes")
    ax.set_ylabel("Weight")
    ax.set_title("Weight plot with error bars")
    plt.legend()
    plt.savefig("errorbar.png", dpi=300)

    plt.show()


def graphgenerator():
    with open("../test/data/graphdata2.json") as f:
        file = json.load(f)
    solvertimelist = file["solvertimelist"]
    heurtimelist_latency = file["heurtimelist_latency"]
    heurtimelist_weight = file["heurtimelist_weight"]
    solveravglist = file["solveravglist"]
    heuravglist_latency = file["heuravglist_latency"]
    heuravglist_weight = file["heuravglist_weight"]
    heurstd_latency = file["heurstd_latency"]
    heurstd_weight = file["heurstd_weight"]
    solstd = file["solstd"]
    nodes = file["nodes"]

    draw_errorbar(
        nodes, heuravglist_latency, heurstd_latency, "Latenct Heuristic Std Error"
    )

    draw_errorbar(nodes, solveravglist, solstd, "SolverStd Error")

    draw_errorbar(
        nodes, heuravglist_weight, heurstd_weight, "Weight Heuristic Std Error"
    )

    draw_comparisiontime(
        nodes, solvertimelist, heurtimelist_latency, heurtimelist_weight
    )

    draw_weightcomparison(nodes, heuravglist_latency, heuravglist_weight, solveravglist)

    draw_errorplotweightplot(
        nodes,
        heuravglist_latency,
        heurstd_latency,
        heuravglist_weight,
        heurstd_weight,
        solveravglist,
        solstd,
    )


def test(latency, nodes, n, samplenumber, coefficient, bwlimit):
    data = []
    length = int(nodes[1] - nodes[0])
    for i in range(length):
        for c in range(samplenumber):
            answer = lbnxgraphgenerator(nodes[0] + i, 0.2, 1000, 20)
            check = answer[2]
            if not isinstance(check, str):
                # result = [latencyoutput,latencytime,weightoutput,weighttime]
                heur = answer[0]
                heurtime = answer[1]
                weight = answer[2]
                weighttime = answer[3]
                with open("./tests/data/LB_data.json") as f:
                    data = json.load(f)
                solveranswer = runMC_Solver(data)
                solver = solveranswer[0]
                solvertime = solveranswer[1]
                node = nodes[0] + i
                data.append(
                    [solver, heur, solvertime, heurtime, weight, weighttime, node, i]
                )
            else:
                data.append(
                    [solver, heur, solvertime, heurtime, weight, weighttime, node, i]
                )

    # print("data:"+str(data))
    solvertimelist = []
    heurtimelist_latency = []
    heurtimelist_weight = []
    solveravglist = []
    heuravglist_latency = []
    heuravglist_weight = []
    heurstd_latency = []
    heurstd_weight = []
    solstd = []

    for n in range(length):
        solvertime = []
        heurtime = []
        weighttime = []
        solversol = []
        heursol = []
        weightsol = []
        c = 0
        while c < samplenumber:
            solversol.append(data[n * samplenumber + c][0])
            heursol.append(data[n * samplenumber + c][1])
            solvertime.append(data[n * samplenumber + c][2])
            heurtime.append(data[n * samplenumber + c][3])
            weightsol.append(data[n * samplenumber + c][4])
            weighttime.append(data[n * samplenumber + c][5])
            c = c + 1
        solvertimelist.append(np.mean(solvertime))
        heurtimelist_latency.append(np.mean(heurtime))
        heurtimelist_weight.append(np.mean(weighttime))
        solveravglist.append(np.mean(solversol))
        heuravglist_latency.append(np.mean(heursol))
        heuravglist_weight.append(np.mean(weightsol))
        solstd.append(np.std(solversol))
        heurstd_latency.append(np.std(heursol))
        heurstd_weight.append(np.std(weightsol))

    file = {}
    file["solvertimelist"] = solvertimelist
    file["heurtimelist_latency"] = heurtimelist_latency
    file["heurtimelist_weight"] = heurtimelist_weight
    file["solveravglist"] = solveravglist
    file["heuravglist_latency"] = heuravglist_latency
    file["heuravglist_weight"] = heuravglist_weight
    file["heurstd_latency"] = heurstd_latency
    file["heurstd_weight"] = heurstd_weight
    file["solstd"] = solstd
    file["nodes"] = nodes

    filesave(file)
    graphgenerator()


#
# test(nodes=[18,21],n=0.2,samplenumber=10, coefficient=7,latency = 1000, bwlimit = 20)
#

1	import json	×
2
3	import matplotlib.pyplot as plt	×
4	import numpy as np	×
5
6	from LoadBalancing.MC_Solver import runMC_Solver	×
7	from LoadBalancing.RandomTopologyGenerator import lbnxgraphgenerator	×
8
9
10	def filesave(file):	×
11	with open("../test/data/graphdata2.json", "w") as json_file:	×
12	json.dump(file, json_file, indent=4)	×
13
14
15	def draw_errorbar(nodes, avglist, std, name):	×
16	labels = []	×
17	x_axis = []	×
18	for num in range(nodes[0], nodes[1]):	×
19	labels.append(str(num))	×
20	x_axis.append(num)	×
21
22	x_pos = np.arange(len(labels))	×
23	fig, ax = plt.subplots()	×
24	ax.bar(	×
25	x_pos, avglist, yerr=std, align="center", alpha=0.5, ecolor="black", capsize=10
26	)
27
28	ax.set_xticks(x_pos)	×
29	ax.set_xticklabels(labels)	×
30	ax.set_title(name)	×
31	ax.yaxis.grid(True)	×
32	ax.set_xlabel("Number of Nodes")	×
33	ax.set_ylabel("Path Weights")	×
34
35	plt.tight_layout()	×
36	plt.savefig("Heuristic Std Error.png", dpi=300)	×
37	plt.show()	×
38
39
40	def draw_comparisiontime(	×
41	nodes, solvertimelist, heurtimelist_latency, heurtimelist_weight
42	):
43	labels = []	×
44	x_axis = []	×
45	for num in range(nodes[0], nodes[1]):	×
46	labels.append(str(num))	×
47	x_axis.append(num)	×
48
49	plt.plot(x_axis, solvertimelist, label="solver")	×
50	plt.plot(x_axis, heurtimelist_latency, label="latency")	×
51	plt.plot(x_axis, heurtimelist_weight, label="weight")	×
52	plt.xlabel("Number of Nodes")	×
53	plt.ylabel("Milliseconds")	×
54	plt.title("Computation Time: Solver Vs Heuristic")	×
55	plt.legend()	×
56	plt.savefig("Computatoin Time", dpi=300)	×
57	plt.show()	×
58
59
60	def draw_weightcomparison(	×
61	nodes, heuravglist_latency, heuravglist_weight, solveravglist
62	):
63
64	Y = heuravglist_latency	×
65	Z = solveravglist	×
66	W = heuravglist_weight	×
67
68	X = list(range(nodes[0], nodes[1]))	×
69
70	X_axis = np.arange(len(X))	×
71	width = 0.25	×
72
73	plt.bar(X_axis, Y, width, label="Latency Solution")	×
74	plt.bar(X_axis + width, W, width, label="Weight Solution")	×
75	plt.bar(X_axis + 2 * width, Z, width, label="Solver Solution")	×
76
77	plt.xticks(X_axis, X)	×
78	plt.xlabel("Nodes")	×
79	plt.ylabel("NWeights")	×
80	plt.title("Heuristic VS Solver (Sorted by latency)")	×
81	plt.legend()	×
82	plt.savefig("Weights comparision.png", dpi=300)	×
83	plt.show()	×
84
85
86	def draw_errorplotweightplot(	×
87	nodes,
88	heuravglist_latency,
89	heurstd_latency,
90	heuravglist_weight,
91	heurstd_weight,
92	solveravglist,
93	solstd,
94	):
95	W = heuravglist_weight	×
96	Y = heuravglist_latency	×
97	Z = solveravglist	×
98	Yerr = heurstd_latency	×
99	Zerr = solstd	×
100	Werr = heurstd_weight	×
101
102	x_axis = np.linspace(nodes[0], nodes[1] - 1, nodes[1] - nodes[0])	×
103
104	fig, ax = plt.subplots()	×
105
106	ax.errorbar(x_axis, W, yerr=Werr, fmt="-o", label="weight")	×
107	ax.errorbar(x_axis, Y, yerr=Yerr, fmt="-o", label="Latency")	×
108	ax.errorbar(x_axis, Z, yerr=Zerr, fmt="-o", label="Solver")	×
109
110	ax.set_xlabel("Nodes")	×
111	ax.set_ylabel("Weight")	×
112	ax.set_title("Weight plot with error bars")	×
113	plt.legend()	×
114	plt.savefig("errorbar.png", dpi=300)	×
115
116	plt.show()	×
117
118
119	def graphgenerator():	×
120	with open("../test/data/graphdata2.json") as f:	×
121	file = json.load(f)	×
122	solvertimelist = file["solvertimelist"]	×
123	heurtimelist_latency = file["heurtimelist_latency"]	×
124	heurtimelist_weight = file["heurtimelist_weight"]	×
125	solveravglist = file["solveravglist"]	×
126	heuravglist_latency = file["heuravglist_latency"]	×
127	heuravglist_weight = file["heuravglist_weight"]	×
128	heurstd_latency = file["heurstd_latency"]	×
129	heurstd_weight = file["heurstd_weight"]	×
130	solstd = file["solstd"]	×
131	nodes = file["nodes"]	×
132
133	draw_errorbar(	×
134	nodes, heuravglist_latency, heurstd_latency, "Latenct Heuristic Std Error"
135	)
136
137	draw_errorbar(nodes, solveravglist, solstd, "SolverStd Error")	×
138
139	draw_errorbar(	×
140	nodes, heuravglist_weight, heurstd_weight, "Weight Heuristic Std Error"
141	)
142
143	draw_comparisiontime(	×
144	nodes, solvertimelist, heurtimelist_latency, heurtimelist_weight
145	)
146
147	draw_weightcomparison(nodes, heuravglist_latency, heuravglist_weight, solveravglist)	×
148
149	draw_errorplotweightplot(	×
150	nodes,
151	heuravglist_latency,
152	heurstd_latency,
153	heuravglist_weight,
154	heurstd_weight,
155	solveravglist,
156	solstd,
157	)
158
159
160	def test(latency, nodes, n, samplenumber, coefficient, bwlimit):	×
161	data = []	×
162	length = int(nodes[1] - nodes[0])	×
163	for i in range(length):	×
164	for c in range(samplenumber):	×
165	answer = lbnxgraphgenerator(nodes[0] + i, 0.2, 1000, 20)	×
166	check = answer[2]	×
167	if not isinstance(check, str):	×
168	# result = [latencyoutput,latencytime,weightoutput,weighttime]
169	heur = answer[0]	×
170	heurtime = answer[1]	×
171	weight = answer[2]	×
172	weighttime = answer[3]	×
173	with open("./tests/data/LB_data.json") as f:	×
174	data = json.load(f)	×
175	solveranswer = runMC_Solver(data)	×
176	solver = solveranswer[0]	×
177	solvertime = solveranswer[1]	×
178	node = nodes[0] + i	×
179	data.append(	×
180	[solver, heur, solvertime, heurtime, weight, weighttime, node, i]
181	)
182	else:
183	data.append(	×
184	[solver, heur, solvertime, heurtime, weight, weighttime, node, i]
185	)
186
187	# print("data:"+str(data))
188	solvertimelist = []	×
189	heurtimelist_latency = []	×
190	heurtimelist_weight = []	×
191	solveravglist = []	×
192	heuravglist_latency = []	×
193	heuravglist_weight = []	×
194	heurstd_latency = []	×
195	heurstd_weight = []	×
196	solstd = []	×
197
198	for n in range(length):	×
199	solvertime = []	×
200	heurtime = []	×
201	weighttime = []	×
202	solversol = []	×
203	heursol = []	×
204	weightsol = []	×
205	c = 0	×
206	while c < samplenumber:	×
207	solversol.append(data[n * samplenumber + c][0])	×
208	heursol.append(data[n * samplenumber + c][1])	×
209	solvertime.append(data[n * samplenumber + c][2])	×
210	heurtime.append(data[n * samplenumber + c][3])	×
211	weightsol.append(data[n * samplenumber + c][4])	×
212	weighttime.append(data[n * samplenumber + c][5])	×
213	c = c + 1	×
214	solvertimelist.append(np.mean(solvertime))	×
215	heurtimelist_latency.append(np.mean(heurtime))	×
216	heurtimelist_weight.append(np.mean(weighttime))	×
217	solveravglist.append(np.mean(solversol))	×
218	heuravglist_latency.append(np.mean(heursol))	×
219	heuravglist_weight.append(np.mean(weightsol))	×
220	solstd.append(np.std(solversol))	×
221	heurstd_latency.append(np.std(heursol))	×
222	heurstd_weight.append(np.std(weightsol))	×
223
224	file = {}	×
225	file["solvertimelist"] = solvertimelist	×
226	file["heurtimelist_latency"] = heurtimelist_latency	×
227	file["heurtimelist_weight"] = heurtimelist_weight	×
228	file["solveravglist"] = solveravglist	×
229	file["heuravglist_latency"] = heuravglist_latency	×
230	file["heuravglist_weight"] = heuravglist_weight	×
231	file["heurstd_latency"] = heurstd_latency	×
232	file["heurstd_weight"] = heurstd_weight	×
233	file["solstd"] = solstd	×
234	file["nodes"] = nodes	×
235
236	filesave(file)	×
237	graphgenerator()	×
238
239
240	#
241	# test(nodes=[18,21],n=0.2,samplenumber=10, coefficient=7,latency = 1000, bwlimit = 20)
242	#

atlanticwave-sdx / pce / 3680947894

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous