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