Скачиваний:
24
Добавлен:
25.06.2023
Размер:
722.03 Кб
Скачать

buffer = [packs[0].tolist()]

#Список для ресурсных блоков слотов slot_resource_blocks = [[]]

#Список средних скоростей

sub_R_mean_list = [[get_R_mean(slot_resource_blocks, subs, sub_idx, 0) for sub_idx in range(subs_cnt)]]

cur_sub_idx = 0

# Цикл по слотам

for slot_idx in range(1, slot_cnt):

#print(slot_resource_blocks[-1])

#Расчитываем среднюю скорость только для алгоритмаов EB и PF if algorithm in ['Equal Blind', 'Proportional fair']:

#sub_R_mean_list.append(

#[get_R_mean(slot_resource_blocks, subs, sub_idx, slot_idx)

for sub_idx in range(subs_cnt)]

# ) sub_R_mean_list.append(

[get_R_mean_smoothing_filter(slot_resource_blocks, subs, sub_idx, slot_idx, sub_R_mean_list[-1]) for sub_idx in range(subs_cnt)]

)

# Присок АБ с заполненным буфером

 

 

 

 

sub_with_full_buffer = [i

% subs_cnt for i

in range(cur_sub_idx,

cur_sub_idx + subs_cnt) if buffer[-1][i % subs_cnt] != 0]

 

 

cur_sub_idx = (cur_sub_idx + 1) % subs_cnt

 

 

 

# Расчет нового буффера для текущего слота

 

 

 

buffer.append(buffer[-1].copy())

# Копируем буфер прошлого слота

 

# Если буфер у всех АБ пуст переходим к сл слоту

 

 

 

if sub_with_full_buffer:

 

 

 

 

 

 

# Создание списка приоритетов

 

 

 

 

subs_priority_idx

=

get_sub_index(subs[slot_idx].to_list(),

algorithm, sub_with_full_buffer, sub_R_mean_list[-1])

 

 

 

new_slot_res_block = []

 

 

 

 

 

for sub_idx in subs_priority_idx:

 

 

 

# Кол-во ресурсных блоков необходимых АБ

 

 

 

sub_res_block_cnt

 

=

int(np.ceil(buffer[-1][sub_idx]

/

subs[slot_idx][sub_idx]))

 

 

 

 

 

 

# Добавляем необходимое кол-во ресурсных блоков

 

 

new_slot_res_block.extend([sub_idx

for

_

in

range(sub_res_block_cnt)])

 

 

 

 

 

 

# Проверка на превышеняе кол-ва ресурсных блоков в слоте if len(new_slot_res_block) >= Nrb: break

#Записываем респределенные ресурсные блоки слота в список slot_resource_blocks.append(new_slot_res_block[:Nrb])

#Цикл по абанентам, которым выделены ресурсные блоки в текущем

слоте

for sub_idx in [sub_idx for sub_idx in slot_resource_blocks[-1] if sub_idx != -1]:

# Уменьшаем буфер на объем передоваемого АБ сообщения buffer[-1][sub_idx] = max(0, buffer[-1][sub_idx] -

subs[slot_idx][sub_idx]) else:

11

slot_resource_blocks.append([])

# Увеличение буфера на обем пакетов генерируемых входным потоком buffer[-1] = [sub_buf + sub_pac for sub_buf, sub_pac in zip(buffer[-

1], packs[slot_idx])]

#print(packs.sum(axis = 1))

#plt.plot([sum(slot_buffer) for slot_buffer in buffer])

#plt.show()

#Рассчет среднего суммарного буффера слотов

return np.mean([sum(slot_buffer) for slot_buffer in buffer])

# return sum([sum(slot_buffer) for slot_buffer in buffer]) / slot_cnt

def start_model():

'''Функция моделирования работы системы'''

 

 

 

lambd_start = const_var.get("lambd_start")

#

Начальное

значение

интенсивности

 

 

 

 

lambd_end

= const_var.get("lambd_end")

#

Конечное

значение

интенсивности

 

 

 

 

lambd_step

= const_var.get("lambd_step")

# Шаг изменения

 

 

T_rb = const_var.get("T_rb")

# Длительность слота

 

 

# Интенсивность входного потока (Пакетов/сек)

 

 

 

lambd_list = np.arange(lambd_start, lambd_end, lambd_step)

 

 

# Параметр

p геометрического распределения

 

 

 

p_list

= 1 / (lambd_list * T_rb + 1)

 

 

 

# Цикл по кол-ву АБ

 

 

 

 

 

for subs_cnt in const_var.get("subs_list"):

 

 

 

# Генерация расположения АБ

 

 

 

 

subs = subs_generator(subs_cnt)

 

 

 

# print('subs', subs)

# ОТЛАДОЧНАЯ ПЕЧАТЬ

 

 

# Цикл по алгоритмам

 

 

 

 

 

for alg in const_var.get("algoritm_list"):

 

 

 

buffer_score = []

 

 

 

 

 

for p, lambd in zip(p_list, lambd_list):

 

 

 

buffer_score.append(get_mean_buffer_score(subs, p, alg) /

8192)

 

 

 

 

 

 

 

print('subs_cnt = ', subs_cnt, ', lambd = ', lambd, ', alg = ',

alg, ', buffer_score = ', buffer_score[-1], sep='')

 

 

# Добавляем линию на график

 

 

 

plt.plot(lambd_list,

buffer_score,

marker='o',

label

=

str(subs_cnt) + ' ' + alg)

 

 

 

 

 

# Построение графика

 

 

 

 

 

plt.title('Моделирование

для

' + str(const_var.get('slot_cnt')) +

'

слотов')

 

 

 

 

 

 

plt.xlabel('Интенсивность входного потока (пакетов/сек)')

 

 

plt.ylabel('Средн. суммарный объём данных в буфере (Кбайт)') plt.legend()

plt.grid()

plt.show() return 0

if __name__ == "__main__": start_model()

12

Приложение Б. Листинг программы файл конфига

const_var = {

#===============================================

#Общие пораметры моделий

"subs_list"

: [2, 4, 8, 16], # [8, 16, 64], # Список кол-ва АБ

"algoritm_list" : ['Maximum Throughput', 'Equal

Blind', 'Proportional

fair'],

 

 

 

 

"lambd_start" : 1,

# Начальное значение интенсивности

"lambd_end"

: 5000,

# Конечное значение интенсивности

"lambd_step"

: 200,

# Шаг изменения

 

"slot_cnt"

 

: 10**3,

# Кол-во моделируемых слотов

"T_rb"

 

: 5 * 10**-4, # Длительность слота

"cooldown_period"

: 1,

# Период перерасчета средней скорости

(секунд)

 

 

 

 

"cooldown_slot_count"

: round(1 /

(5 * 10**-4)),

# Кол-во слотов, на

котором рассчитывается средняя скорость

 

 

"V" : 1 * 1024 * 8, # Объем данных содержащихся в одном пакете равеный 1

кбайт

 

 

 

 

"T" : 300,

 

# Абсолютная температура

 

#===============================================

#Параметры варианта

#-----------------------------------------------

#Окумура-Хата, small city

"S"

: 0,

# small

city (S =

0)

/

large city (S = 3)

"R"

: 2000,

# Радиус

 

 

 

 

"Ptx"

: 40,

# Мощность излучения

БС

 

"f0"

: 900,

#

Частота БС

 

 

 

"kn"

: 4,

#

Коэф. теплового

шума

приёмника

"Nrb" : 25,

# Кол-во ресурсных

блоков

"h_bs" : 100,

# Высота

БС

"h_rx"

: 5,

 

# Высота

точки приема

"DF"

: 180

* 10**3,

# Полоса

пропускания канала связи

"k"

: 1.38 * 10**-23,

# Постоянная Больцмана

"Pn"

: 180

* 10**3 * 300 * 1.38 * 10**-23 * 4 # Мощность теплового шума

# ===============================================

}

13

Соседние файлы в папке ЛР3