-
Notifications
You must be signed in to change notification settings - Fork 5
/
Copy pathclient_for_phone.py
176 lines (168 loc) · 8.65 KB
/
client_for_phone.py
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
import socket
import json
import time
from functions import unpack
from message import task_message
import _thread
class Client:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
fog_task_id = 1
middle_task_id = 5000
cloud_task_id = 10000
task_message1 = task_message
original_task_message = task_message1
original_task_message['task_id'] = 1
original_task_message['task_type'] = 'medium'
original_task_message['task_name'] = "medium"
original_task_message['time_requirement'] = 0.05
original_task_message['content'] = 1
fog_message = original_task_message.copy()
fog_message['cloud_processing'] = False
cloud_message = original_task_message.copy()
cloud_message['cloud_processing'] = True
performance = {"light_num": 0, "light_delay": 0, "light_in_time": 0, "light_avg_delay": 0, "light_in_time_rate": 0, \
"middle_num": 0, "middle_delay": 0, "middle_in_time": 0, "middle_avg_delay": 0,
"middle_in_time_rate": 0, \
"heavy_num": 0, "heavy_delay": 0, "heavy_in_time": 0, "heavy_avg_delay": 0, "heavy_in_time_rate": 0}
# Specify the maximum allowed offloading time for each task
max_offloading_time = 4
# Specify the task rate for lighweight task
light_task_per_min = 200
if light_task_per_min != 0:
light_delay = 60 / light_task_per_min
light_time_requirement = 0.2 # Specify the time requirement for lighweight task
# Specify the task rate for middleweight task
middle_task_per_min = 40
if middle_task_per_min != 0:
middle_delay = 60 / middle_task_per_min
middle_time_requirement = 2 # Specify the time requirement for middleweight task
# Specify the task rate for heavyweight task
heavy_task_per_min = 0
if heavy_task_per_min != 0:
heavy_delay = 60 / heavy_task_per_min
heavy_time_requirement = 5 # Specify the time requirement for heavyweight task
# Send lighweight task
def sendMessage(self):
while True:
time.sleep(self.light_delay)
light_message = self.task_message1.copy()
light_message['task_id'] = 1
light_message['task_type'] = 'light'
light_message['task_name'] = "light"
light_message['time_requirement'] = self.light_time_requirement
light_message['max_offload'] = self.max_offloading_time
light_message['content'] = 1
light_message['cloud_processing'] = False
task_message = light_message
task_message['task_id'] = self.fog_task_id
task_message['sending_time'] = time.time()
self.fog_task_id += 1
sending_message = bytes(json.dumps(task_message), "ascii")
self.sock.send(sending_message)
# Send middleweight task
def sendMessage2(self):
while True:
time.sleep(self.middle_delay)
middle_message = self.task_message1.copy()
middle_message['task_id'] = 1
middle_message['task_type'] = 'medium'
middle_message['task_name'] = "medium"
middle_message['time_requirement'] = self.middle_time_requirement
middle_message['max_offload'] = self.max_offloading_time
middle_message['content'] = 1
middle_message['cloud_processing'] = False
task_message = middle_message
task_message['task_id'] = self.middle_task_id
task_message['sending_time'] = time.time()
self.middle_task_id += 1
sending_message = bytes(json.dumps(task_message), "ascii")
self.sock.send(sending_message)
# Send heavyweight task
def sendMessage3(self):
while True:
time.sleep(self.heavy_delay)
heavy_message = self.task_message1.copy()
heavy_message['task_id'] = 1
heavy_message['task_type'] = 'heavy'
heavy_message['task_name'] = "heavy"
heavy_message['time_requirement'] = self.heavy_time_requirement
heavy_message['max_offload'] = self.max_offloading_time
heavy_message['content'] = 1
heavy_message['cloud_processing'] = True
task_message = heavy_message
task_message['task_id'] = self.cloud_task_id
task_message['sending_time'] = time.time()
self.cloud_task_id += 1
sending_message = bytes(json.dumps(task_message), "ascii")
self.sock.send(sending_message)
# Send task
def __init__(self, address, port):
self.sock.connect((address, port))
try:
if self.light_task_per_min > 0:
_thread.start_new_thread(self.sendMessage, ())
if self.middle_task_per_min > 0:
_thread.start_new_thread(self.sendMessage2, ())
if self.heavy_task_per_min > 0:
_thread.start_new_thread(self.sendMessage3, ())
except:
print("Error: fail to start thread")
while True:
data = self.sock.recv(1024)
print(data)
if not data:
break
else:
data = data.decode("ascii")
print(data)
unpacked_data = unpack(data)
for data in unpacked_data:
message = json.loads(data)
if message['message_type'] == 'result' and int(message["sending_time"]) != 0:
task_type = message['task_type']
time_requirement = float(message['time_requirement'])
execution_time = float(message['execution_time'])
responding_time = time.time() - float(message['sending_time'])
waiting_time = responding_time - execution_time
offloading_times = message['offload_times']
process_by = message['process_by']
if waiting_time > time_requirement:
is_in_time = 0
else:
is_in_time = 1
print("Required_time: %f" % time_requirement)
print("Waiting_time: %f" % waiting_time)
print("In time or not: %d" % is_in_time)
print("responding_time (delay): %f" % responding_time)
print("offloading_times: %d" % offloading_times)
print("process_by: %s" % process_by)
if task_type == "light":
self.performance["light_num"] += 1
self.performance["light_delay"] += responding_time
self.performance["light_in_time"] += is_in_time
self.performance["light_avg_delay"] = self.performance["light_delay"]/self.performance["light_num"]
self.performance["light_in_time_rate"] = self.performance["light_in_time"]/self.performance["light_num"]
elif task_type == "medium":
self.performance["middle_num"] += 1
self.performance["middle_delay"] += responding_time
self.performance["middle_in_time"] += is_in_time
self.performance["middle_avg_delay"] = self.performance["middle_delay"] / self.performance[
"middle_num"]
self.performance["middle_in_time_rate"] = self.performance["middle_in_time"] / \
self.performance["middle_num"]
elif task_type == "heavy":
self.performance["heavy_num"] += 1
self.performance["heavy_delay"] += responding_time
self.performance["heavy_in_time"] += is_in_time
self.performance["heavy_avg_delay"] = self.performance["heavy_delay"] / self.performance[
"heavy_num"]
self.performance["heavy_in_time_rate"] = self.performance["heavy_in_time"] / \
self.performance["heavy_num"]
print(self.performance)
a = (self.performance["light_delay"] + self.performance["middle_delay"])/(self.performance["light_num"]+self.performance[
"middle_num"])
print(a)
print("")
if __name__=="__main__":
# You need to modify the IP to the actual IP of one of your running fog node
client = Client('192.168.1.9', 10000)