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
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
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 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のインデックスにアクセスするためインクリメント