def resource_adjustment(self, device: Device):
"""
MECのカバー範囲内のデバイスを探すメソッド
:param device: デバイス
:param plan_index: デバイスの計画表（plan）のリストのインデックス
:return memo: 発見したデバイスのID, self.resource: MECの保有リソース量, boolean:発見できたかどうかの判定
"""
#if mode == "add":
if device.mode == "add":
self.resource = self.resource - device.use_resource
#割り当てたMECをデバイスに保存
device._mec_name = self.name
#ホップ数カウント
device.add_hop_count()
print("MEC", self._name, "に", "デバイス", device.name, "追加",
self.resource)
self._test = self._test + 1
#elif mode == "decrease":
elif device.mode == "decrease":
self.resource = self.resource + device.use_resource
device.add_hop_count()
print("デバイス移動")
self._test = self._test - 1
else:
self.resource = self.resource
print("MEC", self._name, "に", "デバイス", device.name, "KEEP",
self.resource)
def continue_mode_adjustment(self, device: Device, plan_index, time,
nearest_range):
if (self.resource > 0) or ((self.resource - device.use_resource) >= 0):
old_distance = distance_calc(float(device.plan[plan_index - 1].y),
float(device.plan[plan_index - 1].x),
self.lat, self.lon)
current_distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x),
self.lat, self.lon)
current_id, device_flag = self.custom_nearest_allocation(
device, plan_index, nearest_range)
#ここのアルゴリズムが間違えてる
#同じIDを割り当て続ける場合
if (device_flag == True and current_id == device.mec_name):
print("MEC", self.name, "KEEP", ", plan_index[", device.name,
"]:", plan_index)
print(device.plan[plan_index], current_distance)
self._mode = "keep"
device.mec_name = self.name
self.add_having_device(time)
return True
else:
return False
else:
return False
def hop_calc(device: Device, mecs: MEC_servers, mec: MEC_server,
previous_mec_name, time):
# ホップ数計算
# 最初の割り当て
if device._first_flag == True:
device._hop = [1]
device._first_flag = False
#elif mec.name == device.mec_name:
#keep_hop(device)
# 切替成功
else:
mec.add_reboot_count(time)
# 集約局が同一の時
if mec_compare(device, mec) == False:
device._three_count = device._three_count + 1
# ---
previous_mec = search_mec(mecs, previous_mec_name)
distance = distance_calc(mec.lat, mec.lon, previous_mec.lat,
previous_mec.lon)
# 割り当て距離を追加
if device._distance is None:
device._distance = [distance]
else:
device._distance.append(distance)
# 最小割り当て距離
if device._min_distance > distance and distance != 0:
device._min_distance = distance
# 最大割り当て距離
if device._max_distance < distance:
device._max_distance = distance
# 集約曲が違う時
else:
device._hop.append(5)
previous_mec = search_mec(mecs, device.mec_name)
# ---
distance = distance_calc(mec.lat, mec.lon, previous_mec.lat,
previous_mec.lon)
# 割り当て距離を追加
if device._distance is None:
device._distance = [distance]
else:
device._distance.append(distance)
# 最小割り当て距離
if device._min_distance > distance and distance != 0:
device._min_distance = distance
# 最大割り当て距離
if device._max_distance < distance:
device._max_distance = distance
def cover_range_search(self, device: Device, plan_index, time):
"""
MECのカバー範囲内のデバイスを探すメソッド
:param device: デバイス
:param plan_index: デバイスの計画表（plan）のリストのインデックス
:return memo: 発見したデバイスのID, self.resource: MECの保有リソース量, boolean:発見できたかどうかの判定
"""
memo = 0
#if mode == "add":
if (self.resource > 0) or ((self.resource - device.use_resource) >= 0):
distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x),
self.lat, self.lon)
#print(self.name, device.name, distance)
if distance <= self.range:
memo = int(self.name)
#print("ADD")
#print("main",memo, distance)
#リソース割り当て
#self.resource_adjustment(device, mode)
if device.mode == "add":
# リソースを減らす
device.add_hop_count()
device.mec_name = self.name
self.add_having_device(time)
if device._lost_flag == True and device.startup_time != time:
self.add_reboot_count(time)
# リソース割り当て
self.custom_resource_adjustment(device, time)
self.save_resource(time)
device.switch_lost_flag = False
else:
self._cnt = self._cnt + 1
return memo, True
else:
return memo, False
else:
return memo, False
def custom_resource_adjustment(self, device: Device, time):
"""
MECのカバー範囲内のデバイスを探すメソッド
:param device: デバイス
:param plan_index: デバイスの計画表（plan）のリストのインデックス
:return memo: 発見したデバイスのID, self.resource: MECの保有リソース量, boolean:発見できたかどうかの判定
"""
#if mode == "add":
if device.mode == "add":
self.resource = self.resource - device.use_resource #MECのリソース量を減らす
if self.name == 11 and time == 98:
print("77777")
print(self.name, self.resource, device.use_resource)
#self.append_having_device(device, time)
device._allocation_check = device._allocation_check + 1 #device._allocation_checkをインクリメント 初期値0
#割り当てたMECをデバイスに保存
device._mec_name = self.name
#ホップ数カウント
#device.add_hop_count()
print("MEC", self._name, "に", "デバイス", device.name, "追加",
self.resource)
self.add_allocation_count(time) #時間timeにおけるdeviceの割り当て回数をインクリメント
self._test = self._test + 1 #testをインクリメント 初期値0
#elif mode == "decrease":
elif device.mode == "decrease":
self.resource = self.resource + device.use_resource #MECのリソース量を増やす(戻す)
#self.decrease_having_device(time)
device._allocation_check = device._allocation_check - 1 #device._allocation_checkをデクリメント
#device.add_hop_count()
print("デバイス移動")
self._test = self._test - 1 #testをデクリメント
#else mode == "keep":
else:
self.resource = self.resource
print("MEC", self._name, "に", "デバイス", device.name, "KEEP",
self.resource)
def custom_continue_allocation(self, nearest_range, device: Device,
plan_index, time):
memo = 0
#if mode == "add":
if (self.resource > 0) or ((self.resource - device.use_resource) >= 0):
distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x),
self.lat, self.lon)
#print(self.name, device.name, distance)
if distance <= nearest_range:
memo = int(self.name)
if self._mode == "add":
self.add_having_device(time)
device.mec_name = self.name
# リソース割り当て
self.resource_adjustment(device, self._mode)
else:
self._cnt = self._cnt + 1
return memo, True
else:
return memo, False
else:
return memo, False
d_speed = Speed(d_time, row['vehicle_speed'])
d_plan = Point3D(d_lon, d_lat, d_time)
dflag = 0
for d in devices:
#情報の追加
if d.name == d_name:
d.append_speed(d_speed)
d.append_plan(d_plan)
d.append_angle(d_angle)
dflag = 1
break
if dflag == 0:
d = Device(name=d_name)
d.startup_time = d_time
d.append_plan(d_plan)
d.append_speed(d_speed)
d.append_angle(d_angle)
d._system_time = 500
d.set_congestion_status(500)
d.use_resource = 1
d._app_ver = random.randint(1, 3) #利用するAPの情報を付与
devices.append(d)
num += 1
device_num = len(devices)
f = open('device.congestion_binaryfile', 'wb')
pickle.dump(devices, f)
def continue_search(device: Device, mec: MEC_servers, plan_index, cover_range,
time, continue_distance):
# 指定時間内なら、継続して割り当てるメソッド
# 継続割り当ての最初の割り当てどうか調べる
# 指定時間内か調べる
# カバー範囲内か判定を行う
#--
#指定時間以内
if device.mec_name != [] and device.mec_name is not None:
print(device.mec_name)
mec_index = int(device.mec_name) - 1
# 指定時間以内 かつ リソース残量OK かつ 稼働時間内
if device._continue_count == 0 and mec[mec_index].check_resource(
device.use_resource) == True and len(device.plan) > plan_index:
distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x),
mec[mec_index].lat, mec[mec_index].lon)
#カバー範囲内なら
#if distance <= cover_range and distance <= continue_distance:
if distance <= continue_distance:
print(device.plan[plan_index])
device.set_mode = "keep"
mec[mec_index].custom_resource_adjustment(device, time)
# 追加
keep_hop(device)
mec[mec_index].add_allocation_count(time)
mec[mec_index]._keep_count = mec[mec_index]._keep_count + 1
print("KEEP", plan_index)
device.mec_name = mec[mec_index].name
mec[mec_index].add_having_device(time)
mec[mec_index].save_resource(time)
device.switch_lost_flag = False
device.set_continue_count("add")
#return True, mec_index
return True, mec[mec_index].name
else:
device.set_continue_count("reset")
return False, mec_index
else:
device.set_continue_count("reset")
return False, mec_index
else:
device.set_continue_count("reset")
return False, 0
for row in reader:
d_name = row['vehicle_id']
d_time = row['timestep_time']
d_lon = row['vehicle_x']
d_lat = row['vehicle_y']
d_angle = Angle(d_time, row['vehicle_angle'])
d_speed = Speed(d_time, row['vehicle_speed'])
d_plan = Point3D(d_lon, d_lat, d_time)
dflag = 0
for d in devices:
#情報の追加
if d.name == d_name:
d.append_speed(d_speed)
d.append_plan(d_plan)
d.append_angle(d_angle)
dflag = 1
break
if dflag == 0:
d = Device(name=d_name)
d.startup_time = d_time
d.append_plan(d_plan)
d.append_speed(d_speed)
d.append_angle(d_angle)
d.use_resource = 1
devices.append(d)
num += 1
f = open('device.binaryfile', 'wb')
pickle.dump(devices, f)
f.close
def nearest_search2(device:Device, mec:MEC_servers, plan_index, cover_range, time):
"""
最近傍法のアルゴリズムでリソース割り当てを行うメソッド
最も近いMECサーバをデバイスに割り当てる
:param device: デバイス
:param mec: MECサーバ群
:param plan_index: デバイスのplanのindex
:param cover_range: 基地局のカバー範囲
:param time: 現在時刻t
:return: 割り当てたans_idをTrueと共に返す, 割り当てられなかった時はFalseを返す
"""
data = len(mec)
distance = collections.namedtuple("distance", ("index", "value", "flag"))
mec_distance = [distance] * data
cnt = 0
# 最近傍法を使うために、各MECサーバとの距離を計算
for m in range(data):
if mec[m].check_resource(device.use_resource) == True and len(device.plan) > plan_index:
tmp_distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x), mec[m].lat, mec[m].lon)
mec_distance[m] = distance(m, tmp_distance, True)
else:
mec_distance[m] = distance(m, 100000000, False)
cnt = cnt + 1
#print(distance)
#ans_id = distance.index(min(distance))
sorted_distance = sorted(mec_distance, key=lambda m:m.value)
index_count = 0
while(True):
finish_len = len(sorted_distance)
if index_count == finish_len:
print("MECのリソース量が少な過ぎます")
sys.exit()
return False, mec[0].name
# 最も距離が近い割り当て可能なMECサーバを選び、その配列のインデックスを取得する
ans_id = sorted_distance[index_count].index
if mec[ans_id].resource > 0:
#継続割り当ての時
if mec[ans_id].name == device.mec_name:
device.set_mode = "keep"
mec[ans_id].custom_resource_adjustment(device, time)
print("KEEP", plan_index)
device.mec_name = mec[ans_id].name
mec[ans_id].add_having_device(time)
mec[ans_id].save_resource(time)
device.switch_lost_flag = False
# 追加項目
keep_hop(device)
print(mec[ans_id].aggregation_station)
device._aggregation_name = mec[ans_id].aggregation_station
mec[ans_id].add_allocation_count(time)
mec[ans_id]._keep_count = mec[ans_id]._keep_count + 1
# 移動する時(新規割り当て以外)
elif mec[ans_id].name != device.mec_name and mec[ans_id].name != None and device.mec_name != []:
print("********")
print(mec[ans_id].name, device.mec_name)
previous_index = search_mec_index(mec, device.mec_name)
#mec_index = mec_index_search(device, mec)
# リソースを増やす
device.set_mode = "decrease"
print("デバイスの前のMEC:", device.mec_name, "前のMEC", mec[previous_index].name)
# 前に割り振ったMECのリソースを回復
mec[previous_index].custom_resource_adjustment(device, time)
device.add_hop_count()
#hop_calc(device, mec[device.mec_name - 1])
mec[previous_index].save_resource(time)
print("DECREASE")
print("切替", device._aggregation_name, mec[ans_id])
previous_mec_name = device.mec_name
# リソースを減らす
device.set_mode = "add"
hop_calc(device, mec, mec[ans_id], previous_mec_name, time)
mec[ans_id].custom_resource_adjustment(device, time)
device.add_hop_count()
# 新規追加
device._aggregation_name = mec[ans_id].aggregation_station
device.mec_name = mec[ans_id].name
mec[ans_id].add_having_device(time)
mec[ans_id].save_resource(time)
device.switch_lost_flag = False
else:
# リソースを減らす
device.set_mode = "add"
mec[ans_id].custom_resource_adjustment(device, time)
device.add_hop_count()
device.mec_name = mec[ans_id].name
# 新規追加
previous_mec_name = device.mec_name
hop_calc(device, mec, mec[ans_id], previous_mec_name, time)
#keep_hop(device)
device._aggregation_name = mec[ans_id].aggregation_station
mec[ans_id].add_having_device(time)
mec[ans_id].save_resource(time)
device.switch_lost_flag = False
print("MEC_RESOURCE", mec[ans_id].resource)
return True, mec[ans_id].name
index_count = index_count + 1
def nearest_search(device:Device, mec:MEC_servers, plan_index, cover_range, time):
"""
最近傍法のアルゴリズムでリソース割り当てを行うメソッド
最も近いMECサーバをデバイスに割り当てる
:param device: デバイス
:param mec: MECサーバ群
:param plan_index: デバイスのplanのindex
:param cover_range: 基地局のカバー範囲
:param time: 現在時刻t
:return: 割り当てたans_idをTrueと共に返す, 割り当てられなかった時はFalseを返す
"""
# data = len(mec)
data = 100
distance = [None] * data
cnt = 0
# 最近傍法を使うために、各MECサーバとの距離を計算
for m in range(data):
if mec[m].check_resource(device.use_resource) == True and len(device.plan) > plan_index:
distance[m] = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x), mec[m].lat, mec[m].lon)
else:
distance[m] = 100000000000
cnt = cnt + 1
if cnt < data:
# 最も距離が近いMECサーバを選び、その配列のインデックスを取得する
ans_id = distance.index(min(distance))
# 最も距離が近いMECサーバを選び、その配列のインデックスを取得する
print(device.mec_name)
ans_id = mec[ans_id].name
print(mec[ans_id].name, device.mec_name, device.lost_flag)
#継続割り当ての時
if mec[ans_id].name == device.mec_name and device.lost_flag == False:
print(device.plan[plan_index])
device.set_mode = "keep"
mec[ans_id].custom_resource_adjustment(device, time)
print("KEEP", plan_index)
device.mec_name = mec[ans_id].name
device._allocation_plan[time] = mec[ans_id]
mec[ans_id].add_having_device(time)
mec[ans_id].save_resource(time)
device.switch_lost_flag = False
# 追加項目
keep_hop(device)
#hop_calc(device, mec, ans_id, time)
print(mec[ans_id].aggregation_station)
device._aggregation_name = mec[ans_id].aggregation_station
mec[ans_id].add_allocation_count(time)
mec[ans_id]._keep_count = mec[ans_id]._keep_count + 1
# 移動する時(新規割り当て以外)
elif mec[ans_id].name != device.mec_name and device._lost_flag == False and mec[ans_id].name != None:
# リソースを増やす
device.set_mode = "decrease"
mec[device.mec_name - 1].custom_resource_adjustment(device, time)
device.add_hop_count()
#hop_calc(device, mec[device.mec_name - 1])
mec[device.mec_name - 1].save_resource(time)
print("DECREASE")
print("切替", device._aggregation_name, mec[ans_id])
previous_mec_name = device.mec_name
# リソースを減らす
device.set_mode = "add"
mec[ans_id].custom_resource_adjustment(device, time)
device.mec_name = mec[ans_id].name
device._allocation_plan[time] = mec[ans_id]
# 新規追加
hop_calc(device, mec, mec[ans_id], previous_mec_name, time)
device._aggregation_name = mec[ans_id].aggregation_station
mec[ans_id].add_having_device(time)
mec[ans_id].save_resource(time)
device.switch_lost_flag = False
else:
# リソースを減らす
device.set_mode = "add"
mec[ans_id].custom_resource_adjustment(device, time)
device.mec_name = mec[ans_id].name
device._allocation_plan[time] = mec[ans_id]
# 新規追加
#hop_calc(device, mec, ans_id, time)
#hop_calc(device, mec, mec[ans_id], time)
keep_hop(device)
device._aggregation_name = mec[ans_id].aggregation_station
mec[ans_id].add_having_device(time)
mec[ans_id].save_resource(time)
#if device._lost_flag == True and device.startup_time != time:
#mec[ans_id].add_reboot_count(time)
device.switch_lost_flag = False
return True, ans_id
else:
# lostした時リソースを増やす
#if device._lost_flag == False and check_add_device(device, time) == False:
if device._lost_flag == False:
device.set_mode = "decrease"
print("DECREASE")
mec[device.mec_name - 1].custom_resource_adjustment(device, time)
#device.add_hop_count()
mec[device.mec_name - 1].save_resource(time)
device.set_mode = "add"
#print(device._lost_flag)
device.switch_lost_flag = True
device._lost_flag = True
device.mec_name = None
ans_id = None
print("---------------")
return False, ans_id
def nearest_search(device: Device, mec: MEC_servers, plan_index, cover_range,
time):
"""
最近傍法のアルゴリズムでリソース割り当てを行うメソッド
最も近いMECサーバをデバイスに割り当てる
:param device: デバイス
:param mec: MECサーバ群
:param plan_index: デバイスのplanのindex
:param cover_range: 基地局のカバー範囲
:param time: 現在時刻t
:return: 割り当てたans_idをTrueと共に返す, 割り当てられなかった時はFalseを返す
"""
data = len(mec)
distance = collections.namedtuple("distance", ("index", "value", "flag"))
mec_distance = [distance] * data
cnt = 0 #Falseの回数をカウント
# 最近傍法を使うために、各MECサーバとの距離を計算
for m in range(data):
if mec[m].check_resource(
device.use_resource) == True and len(device.plan) > plan_index:
tmp_distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x),
mec[m].lat, mec[m].lon)
mec_distance[m] = distance(m, tmp_distance, True)
else:
mec_distance[m] = distance(m, 100000000, False)
cnt = cnt + 1
#print(distance)
sorted_distance = sorted(mec_distance,
key=lambda m: m.value) #MECサーバとの距離を近い順にソート
index_count = 0
ap_num = 2 #MECで実行可能なAPの種類
while (True):
finish_len = len(sorted_distance) #MECサーバ数
if index_count == finish_len:
print("MECのリソース量が少な過ぎます")
sys.exit()
return False, mec[0].name
# 最も距離が近い割り当て可能なMECサーバを選び、その配列のインデックスを取得する
ans_id = sorted_distance[index_count].index
run_flag = False #実行可能かどうか判定するためのフラグを初期化
#取得したインデックスのMECの実行可能APで実行可能かどうか判定する
for t in range(ap_num):
if device.app_ver == mec[ans_id].app_ver[t]:
run_flag = True
#MECの実行可能APの場合(ダメな場合は次のMECへ)
if run_flag == True:
#取得したインデックスのMECのリソース量を確認する(ans_id > 0):ダメなら次のMECへ
if mec[ans_id].resource > 0:
#継続割り当ての時
if mec[ans_id].name == device.mec_name: #今回割り当てようとしているMECと前回割り当てたMECが同じ場合
device.set_mode = "keep" #deviceのmoodをkeepに更新
mec[ans_id].custom_resource_adjustment(
device, time) #MECのリソースの調整("keep"なのでMECのリソース量に変化なし)
print("KEEP", plan_index)
device.mec_name = mec[ans_id].name #デバイスに割り当てたMECの名前を保存
mec[ans_id].add_having_device(
time) #having_devices_count[time]をインクリメント
mec[ans_id].save_resource(
time
) #ある時刻tのMECのリソース状態を保存するメソッド(resource_per_second[time] = resource)
device.switch_lost_flag = False #lost_flag = False
# 追加項目
keep_hop(device) #同じ基地局に割り当てる場合(ホップ数1)
print(mec[ans_id].aggregation_station)
device._aggregation_name = mec[
ans_id].aggregation_station #deviceの集約局名を割り当てるMECの集約局名に更新
mec[ans_id].add_allocation_count(
time) #add_allocation_count[time]をインクリメント
mec[ans_id]._keep_count = mec[
ans_id]._keep_count + 1 #keep_countをインクリメント 初期値0
# 移動する時(新規割り当て以外)
elif mec[ans_id].name != device.mec_name and mec[
ans_id].name != None and device.mec_name != []:
#deviceに割り当てていたMECと今回のMECの名前が違い、今回のMECの名前が空ではなく、前回deviceに割り当てたMECの名前の配列の中身がない
print("********")
print(mec[ans_id].name, device.mec_name)
previous_index = search_mec_index(
mec, device.mec_name) #以前にデバイスに割り当てていたMECのインデックスを取得
#mec_index = mec_index_search(device, mec)
# リソースを増やす
device.set_mode = "decrease"
print("デバイスの前のMEC:", device.mec_name, "前のMEC",
mec[previous_index].name)
# 前に割り振ったMECのリソースを回復
mec[previous_index].custom_resource_adjustment(
device, time) #以前にデバイスを割り当てていたMECのリソースを調整(増やす)
device.add_hop_count() #デバイスのhop_countを更新 hop_count 初期値0
#hop_calc(device, mec[device.mec_name - 1])
mec[previous_index].save_resource(
time
) #ある時刻tのMECのリソース状態を保存するメソッド(resource_per_second[time] = resource):今回の場合は以前に割り当てたMEC
print("DECREASE")
print("切替", device._aggregation_name, mec[ans_id])
previous_mec_name = device.mec_name #以前(previous)のMECの名前:ホップ数計算のため
# リソースを減らす
device.set_mode = "add"
hop_calc(device, mec, mec[ans_id], previous_mec_name,
time) #ホップ数の計算
mec[ans_id].custom_resource_adjustment(
device, time) #MECサーバのリソース量を調整する
device.add_hop_count() #デバイスのhop_countを更新 hop_count 初期値0
# 新規追加
device._aggregation_name = mec[
ans_id].aggregation_station #deviceの集約局名を割り当てるMECの集約局名に更新
device.mec_name = mec[ans_id].name #デバイスに割り当てたMECの名前を保存
#mec[ans_id].add_allocation_count(time) #add_allocation_count[time]をインクリメント
mec[ans_id].add_having_device(
time) #having_devices_count[time]をインクリメント
mec[ans_id].save_resource(
time
) #ある時刻tのMECのリソース状態を保存するメソッド(resource_per_second[time] = resource)
device.switch_lost_flag = False #lost_flag = False
#新規割り当て(初回)
else:
# リソースを減らす
device.set_mode = "add"
mec[ans_id].custom_resource_adjustment(
device, time) #MECサーバのリソース量を調整するメソッド
device.add_hop_count() #デバイスのhop_countを更新 hop_count 初期値0
device.mec_name = mec[ans_id].name #デバイスに割り当てたMECの名前を保存
# 新規追加
previous_mec_name = device.mec_name #以前(previous)のMECの名前:ホップ数計算のため
hop_calc(device, mec, mec[ans_id], previous_mec_name,
time) #ホップ数の計算
#keep_hop(device)
device._aggregation_name = mec[
ans_id].aggregation_station #deviceの集約局名を割り当てるMECの集約局名に更新
#mec[ans_id].add_allocation_count(time) #add_allocation_count[time]をインクリメント
mec[ans_id].add_having_device(
time) #having_devices_count[time]をインクリメント
mec[ans_id].save_resource(
time
) #ある時刻tのMECのリソース状態を保存するメソッド(resource_per_second[time] = resource)
device.switch_lost_flag = False #lost_flag = False
print("MEC_RESOURCE", mec[ans_id].resource)
return True, mec[
ans_id].name #(継続 or 切替 or 継続)の処理が終わったのでTrueとデバイスに割り当てたMECの名前を返す
index_count = index_count + 1
#MECで実行可能なAPではなかった場合
index_count = index_count + 1 #次のMECのインデックスにアクセスするためインクリメント
def mode_adjustment(self, device: Device, plan_index, time):
"""
デバイスのリソースを調整するモードを返すメソッド
・新規でデバイスを割り当てるaddモード
・t-1秒に割り当てれたMECとt秒に割り当てるMECが同じ時に割り当て続けるkeepモード
・t-1秒に割り当てれたMECとt秒に割り当てるMECが違う時のdecreaseモード
:param device: デバイス
:param plan_index: デバイスのplanのindex
:param mode: リソース割り当てのモード
:param old_id: t-1秒に割り当てたMECの名前
:param time: 現在時刻t
:return: mode
"""
plan_index = device.plan_index
if (self.resource > 0) or ((self.resource - device.use_resource) >= 0):
old_distance = distance_calc(float(device.plan[plan_index - 1].y),
float(device.plan[plan_index - 1].x),
self.lat, self.lon)
current_distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x),
self.lat, self.lon)
current_id, device_flag = self.custom_cover_range_search(
device, plan_index)
#ここのアルゴリズムが間違えてる
#同じIDを割り当て続ける場合
if (device_flag == True and current_id == device.mec_name):
print("MEC", self.name, "KEEP", ", plan_index[", device.name,
"]:", plan_index)
print(device.plan[plan_index], current_distance)
self._mode = "keep"
device.set_mode = "keep"
device.mec_name = self.name
self.add_having_device(time)
self.save_resource(time)
device.switch_lost_flag = False
elif device_flag == True and current_id != device.mec_name and check_add_device(
device, time) == False:
print("DECREASE")
self._mode = "decrease"
device.set_mode = "decrease"
self.resource_adjustment(device)
self._mode = "add"
device.set_mode = "add"
# リソースを増やす
device.set_mode = "decrease"
mec[device.mec_name - 1].custom_resource_adjustment(
device, time)
device.add_hop_count()
#device.hop_calc(self)
mec[device.mec_name - 1].save_resource(time)
print("DECREASE")
# リソースを減らす
device.set_mode = "add"
mec[ans_id].custom_resource_adjustment(device, time)
device.add_hop_count()
device.mec_name = mec[ans_id].name
mec[ans_id].add_having_device(time)
mec[ans_id].add_reboot_count(time)
mec[ans_id].save_resource(time)
device.switch_lost_flag = False
else:
self._mode = "add"
device.set_mode = "add"
def hop_calc(device: Device, mecs: MEC_servers, mec: MEC_server,
previous_mec_name, time):
"""
ホップ数を計算するメソッド
:param device: デバイス
:param mecs: MECサーバ群
:param mec: 対象のMECサーバ
:param previous_mec_name: 以前に割り当てたMECの名前
:param time: 現在時刻
"""
# ホップ数計算
# 最初の割り当て
if device._first_flag == True: #first_flag 初期値True
device._hop = [1] #device._hop = [1]で更新
device._first_flag = False
#elif mec.name == device.mec_name:
#keep_hop(device)
# 切替成功
#first_flag = Falseのとき
else:
mec.add_reboot_count(time) #reboot_count[time]をインクリメント
# 集約局が同一の時
if mec_compare(device, mec) == False:
device._three_count = device._three_count + 1 #インクリメント
# ---
device._hop.append(3) # ホップ数の追加
previous_mec = search_mec(mecs,
previous_mec_name) #以前のMECのオブジェクトを取得
distance = distance_calc(
mec.lat, mec.lon, previous_mec.lat,
previous_mec.lon) #以前のMECと今回割り当てるMECの距離を計算
# 割り当て距離を追加
if device._distance is None:
device._distance = [distance]
else:
device._distance.append(distance)
# 最小割り当て距離の更新
if device._min_distance > distance and distance != 0:
device._min_distance = distance
# 最大割り当て距離の更新
if device._max_distance < distance:
device._max_distance = distance
# 集約局が違う時
else:
device._hop.append(5) #ホップ数の追加
previous_mec = search_mec(mecs, device.mec_name)
distance = distance_calc(mec.lat, mec.lon, previous_mec.lat,
previous_mec.lon)
# 割り当て距離を追加
if device._distance is None:
device._distance = [distance]
else:
device._distance.append(distance)
# 最小割り当て距離の計算
if device._min_distance > distance and distance != 0:
device._min_distance = distance
# 最大割り当て距離の計算
if device._max_distance < distance:
device._max_distance = distance
d_lat = row['vehicle_y']
d_angle = Angle(d_time, row['vehicle_angle'])
d_speed = Speed(d_time, row['vehicle_speed'])
d_plan = Point3D(d_lon, d_lat, d_time)
dflag = 0
for d in devices:
#情報の追加
if d.name == d_name:
d.append_speed(d_speed)
d.append_plan(d_plan)
d.append_angle(d_angle)
dflag = 1
break
if dflag == 0:
d = Device(name=d_name)
d.startup_time = d_time
d.append_plan(d_plan)
d.append_speed(d_speed)
d.append_angle(d_angle)
#d.use_resource = 1
d._system_time = 100
d.set_congestion_status(100)
d.use_resource = 1
#d.use_resource = random.randint(1, 3)
devices.append(d)
num += 1
f = open('device.congestion_binaryfile', 'wb')
pickle.dump(devices, f)
f.close
def mode_adjustment(mecs: MEC_servers, mec_index, device: Device, time):
"""
割り当てモードの調整するメソッド
ここでリソースの調整も行う
:param mecs: MEC群
:param mec_index: MECのインデックス
:param device: あるデバイス
:param time: ある時刻t
"""
current_id = mecs[mec_index].name
print("割り振るMEC_ID", current_id, "前に割り振ったMEC_ID", device.mec_name)
mec_index = search_mec_index(mecs, current_id)
if (current_id == device.mec_name):
print("KEEP")
# デバイスをkeepモードにセット
device.set_mode = "keep"
# デバイスに割り振るMECの名前を保存
device.mec_name = mecs[mec_index].name
# MECに割り当てられたデバイスを追加
mecs[mec_index].add_having_device(time)
# MECのリソースを保存
mecs[mec_index].save_resource(time)
device.switch_lost_flag = False
# 割り当てるMECを保存
current_id = mecs[mec_index].name
# ホップ数加算
#hop_calc(device, mecs, mec_index, time)
keep_hop(device)
# 割り当て先のMECの管理する集約局を保存
device._aggregation_name = mecs[mec_index].aggregation_station
# 割り当て回数を加算
mecs[mec_index].add_allocation_count(time)
# keep処理の回数を加算
mecs[mec_index]._keep_count = mecs[mec_index]._keep_count + 1
return True, current_id
# 切替&切替先を見つけている時
elif current_id != device.mec_name and check_add_device(
device, time
) == False and device.mec_name != [] and device.mec_name is not None:
# リソースを増やす
# デバイスに保存した前のMECのインデックスを習得する。
previous_index = search_mec_index(mecs, device.mec_name)
print("DECREASE(main)")
device.set_mode = "decrease"
print(previous_index, device.mec_name)
print("増やす前のMECのID", device.mec_name, mecs[previous_index].name)
print("増やす前のリソース", mecs[previous_index].resource)
# リソース調整
mecs[previous_index].custom_resource_adjustment(device, time)
# この時刻のリソース量をセーブ
mecs[previous_index].save_resource(time)
# デバイスに保存した前に割り当てたMECの名前を保存
previous_mec_name = device.mec_name
print("ADD")
hop_calc(device, mecs, mecs[mec_index], previous_mec_name, time)
print("減らす前のID", mecs[mec_index].name)
print("減らす前のリソース", mecs[mec_index].resource)
print(mec_index, previous_index)
device.set_mode = "add"
device.mec_name = mecs[mec_index].name
mecs[mec_index].add_having_device(time)
mecs[mec_index].custom_resource_adjustment(device, time)
mecs[mec_index].save_resource(time)
print("減らした後のリソース", mecs[previous_index].resource)
device.switch_lost_flag = False
current_id = mecs[mec_index].name
# 新規追加
device._aggregation_name = mecs[mec_index].aggregation_station
return True, current_id
# 新規割り当て
#elif current_id != device.mec_name and check_add_device(device, time) == True and device._first_flag == True:
else:
print("ADD")
device.set_mode = "add"
device.mec_name = mecs[mec_index].name
mecs[mec_index].add_having_device(time)
# 新規追加
previous_mec_name = device.mec_name
hop_calc(device, mecs, mecs[mec_index], previous_mec_name, time)
#keep_hop(device)
device._aggregation_name = mecs[mec_index].aggregation_station
mecs[mec_index].custom_resource_adjustment(device, time)
mecs[mec_index].save_resource(time)
device.switch_lost_flag = False
current_id = mecs[mec_index].name
return True, current_id
return False, 1
def continue_search(device:Device, mec:MEC_servers, plan_index, cover_range, time, continue_distance):
# 指定時間内なら、継続して割り当てるメソッド
# 継続割り当ての最初の割り当てどうか調べる
# 指定時間内か調べる
# カバー範囲内か判定を行う
#--
#指定時間以内かどうか
if device.mec_name != [] and device.mec_name is not None:
print(device.mec_name)
mec_index = int(device.mec_name) - 1 #デバイスを割り当てていたMECのインデックスを取得
# 指定時間以内 かつ リソース残量OK かつ 稼働時間内
#device._continue_count == 0 がイマイチ理解できない(継続割り当ては1回まで?)
if device._continue_count == 0 and mec[mec_index].check_resource(device.use_resource) == True and len(device.plan) > plan_index:
distance = distance_calc(float(device.plan[plan_index].y),
float(device.plan[plan_index].x), mec[mec_index].lat, mec[mec_index].lon) #現在のデバイスと割り当てていたMECとの距離を計算
#カバー範囲内なら
#if distance <= cover_range and distance <= continue_distance:
if distance <= continue_distance: #継続割り当て距離内にデバイスがあるかどうか
print(device.plan[plan_index])
device.set_mode = "keep" #deviceのmoodをkeepに更新
mec[mec_index].custom_resource_adjustment(device, time) #MECのリソースの調整("keep"なのでMECのリソース量に変化なし)
# 追加
keep_hop(device) #同じ基地局に割り当てる場合(ホップ数1)
mec[mec_index].add_allocation_count(time) #add_allocation_count[time]をインクリメント
mec[mec_index]._keep_count = mec[mec_index]._keep_count + 1 #keep_countをインクリメント 初期値0
print("KEEP", plan_index)
device.mec_name = mec[mec_index].name #デバイスに割り当てたMECの名前を保存
mec[mec_index].add_having_device(time) #having_devices_count[time]をインクリメント
mec[mec_index].save_resource(time) #ある時刻tのMECのリソース状態を保存するメソッド(resource_per_second[time] = resource)
device.switch_lost_flag = False #lost_flag = False
device.set_continue_count("add") #continue_countを更新(add:+1)
#同じMECに割り当てることが前提のため、集約局の名前の更新は必要ない
#return True, mec_index
return True, mec[mec_index].name
else:
device.set_continue_count("reset") #continue_countを更新(reset:0)
return False, mec_index
else:
device.set_continue_count("reset") #continue_countを更新(reset:0)
return False, mec_index
else:
device.set_continue_count("reset") #continue_countを更新(reset:0)
return False, 0