lab2

ГУАП

КАФЕДРА 41

ОТЧЕТ ЗАЩИЩЕН С ОЦЕНКОЙ

ПРЕПОДАВАТЕЛЬ

ст. преподаватель				Н.В. Апанасенко
должность, уч. степень, звание		подпись, дата		инициалы, фамилия

ОТЧЕТ О ЛАБОРАТОРНОЙ РАБОТЕ №2

Стратегии распределения ресурсных блоков в централизованной сети со случайным трафиком

по курсу: МОДЕЛИРОВАНИЕ СИСТЕМ РАСПРЕДЕЛЕНИЯ РЕСУРСОВ

РАБОТУ ВЫПОЛНИЛ

СТУДЕНТ гр. №	4016				М.О. Жовтяк
			подпись, дата		инициалы, фамилия

Санкт-Петербург 2024

1. Цель.

Получение навыков моделирования стандартных сценариев работы телекоммуникационных систем с топологией типа «звезда». Изучение свойств алгоритмов планирования ресурсов нисходящего кадра в подобных системах. Изучение стратегий распределения ресурсных блоков в централизованной сети со случайным трафиком.

2. Краткие теоретические сведения

Известно, что для каждого абонента максимальная возможная скорость передачи данных или максимальная пропускная способность канала связи С (Сhannel Сapacity) может быть выражена как:

где - полоса пропускания канала связи, - отношение сигнал/шум (Signal-to-Noise Ratio, SNR) у абонента с индексом . Как видно из данной формулы максимальная пропускная способность канала связи зависит от двух параметров, и если значение фиксировано, то значение параметра в общем случае является случайной величиной, зависящей от многих факторов.

где - принятая мощность сигнала, - мощность теплового шума. Мощность теплового шума определяется следующим выражением:

здесь T – абсолютная температура (К), k – постоянная Больцмана , - коэффициент теплового шума приемника .

Очевидным является тот факт, что принятая мощность сигнала определяется излучаемой мощностью БС - и уровнем потерь мощности при преодолении сигналов расстояния от БС к АБ и определяется следующим выражением:

В качестве модели затухания в помещениях (Indoor Propagation Model, IPM) в помещениях рассмотрим разработанной международным союзом связи (International Telecommunication Union, ITU). В рамках этой модели потери L в помещении рассчитывается следующим образом: где K – коэффициент, зависящий от типа помещения, – принять равным нулю, К – принять равным 29. Далее необходимо вычислить приоритеты пользователей на основе разных алгоритмов. Во всех случаях, ресурсный блок будет отдан тому абоненту, у которого выше приоритет. Для показа примера вычислений был рассмотрен пример расчетов для одного пользователя. Первым был рассмотрен алгоритм Maximum Throughput, что выделяет ресурсный блок тому пользователю, у которого максимальна пропускная канала связи. Приоритет пользователя i на ресурсный блок j определяется как: Так, получаем приоритет для пользователя по алгоритму будет равен максимальной пропускной способности пользователя. Чтобы определить, кем будет занят блок нужно определить приоритет каждого из АБ, а после дать блок тому, у кого он больше. В случае этого алгоритма, блок будет отдан тому, у кого больше пропускная способность в этом блоке. Для других двух алгоритмов необходимо рассчитать среднюю скорость на основе сглаженного фильтра по формуле: , где . Далее возможно рассчитать приоритет АБ по алгоритму Equal Blind. Данный алгоритм выравнивает среднюю скорость закачки. Приоритет вычисляется по формуле: Для алгоритма Proportional fair, который выравнивает ресурсы, отдаваемые пользователям, нужно рассчитывать приоритет по формуле: .

3. Ход работы

Вариант работы №14 представлен на рисунке 1.

Рисунок 1 – Вариант работы

_{Моделируется} программа, размещающая случайным образом абонентов вокруг станции со случайно генерируем значением R. Для каждого слота генерируется случайное затухание сигнала согласно формуле _.

_{Также, для каждого абонента и слота формируется пуассоновская случайная величина с параметром λ, в физическом смысле означающую количество пакетов данных V поступающих в буфер БС для передачи абоненту. После этого для сформированных местоположений абонентов рассчитываются величины максимальных скоростей.}

_{В программе производится расчёт значений приоритета пользователей для трёх алгоритмов распределения ресурсов с учётом средней скорости за последнюю секунду. На основе этого строятся графики зависимости среднего суммарного объёма данных, находящихся в буфере от параметра λ, что можно увидеть на рисунке 2.}

Рисунок 2 – График зависимости среднего суммарного объёма данных в буфере от интенсивности входного потока для разных алгоритмов работы с буфером

Для каждого количества пользователей построен подробный график, это представлено на рисунках 3-7.

Рисунок 3 – График зависимости среднего суммарного объёма данных в буфере от интенсивности входного потока для разных алгоритмов работы с буфером (2 пользователя)

Рисунок 4 – График зависимости среднего суммарного объёма данных в буфере от интенсивности входного потока для разных алгоритмов работы с буфером (4 пользователя)

Рисунок 5 – График зависимости среднего суммарного объёма данных в буфере от интенсивности входного потока для разных алгоритмов работы с буфером (8 пользователя)

Рисунок 6 – График зависимости среднего суммарного объёма данных в буфере от интенсивности входного потока для разных алгоритмов работы с буфером (16 пользователя)

Рисунок 7 – График зависимости среднего суммарного объёма данных в буфере от интенсивности входного потока для разных алгоритмов работы с буфером (32 пользователя)

По графику видно, что все алгоритмы ведут себя схожим образом при одинаковом числе пользователей. При этом схожими остаются Equal Blind и Proportional fair, в то время как алгоритм Maximum Throughput показывает немного более худшие результаты – буфер больше заполнен в среднем при одинаковом значении интенсивности.

4. Вывод

В ходе выполнения работы были получены навыки моделирования стандартного сценария работы телекоммуникационных систем с топологией типа «звезда». Были изучены свойства алгоритмов планирования ресурсов нисходящего кадра, а также стратегии распределения ресурсных блоков в централизованной сети со случайным трафиком.

Исходя из результатов можно говорить, что самым оптимальными алгоритмами являются Equal Blind и Proportional fair, так как в среднем размер их буфера меньше, чем у Maximum Throughput хотя их значения приблизительно равны.

ПРИЛОЖЕНИЕ

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

# from numba import njit, prange

from tqdm import tqdm

# Определение параметров по варианту

Rmax = 10 # R (метры)

f0 = 1200 # f0 МГц

p = 0.01 # Ptx Вт

k_n = 3 # k_n - коэффициент теплового шума

N_rb = 50 # Nrb - количество ресурсных блоков

K_boltsman = 1.38 * ( 10**(-23) ) # Постоянная Больцмана

t_rb = 0.0005 # Длина слота, с

y = 1 # Длина временного промежутка, с

y_full = 10 # Весь временной промежуток, с

delta_f = 180 # delta f кГц

T = 300 # Темература

K_const = 29 # Константа из формулы

def get_L(f0, Rmax):

# Создаем случайный радиус до вышки

r = np.sqrt(np.random.uniform(0, Rmax**2))

# Считаем потери

L = 10**((20 * np.log10(f0) + K_const * np.log10(r) - 28) / 10)

return L

cur_L = 10**((20 * np.log10(f0) + K_const * np.log10(15) - 28) / 10)

# Мощность шума

P_n = delta_f * T * K_boltsman * k_n

# Мощность принятая абонентом

P_rx = p / (cur_L) # Затухание со случайной величиной

# Соотношение сигнал/шум

SNR = P_rx / P_n

# Пропускная способность канала связи

np.log2(1+SNR)

# Функция расчета максимальной пропускной способности

def get_C(cur_L):

# Мощность шума

P_n = delta_f * T * K_boltsman * k_n

# Мощность принятая абонентом

P_rx = p / (cur_L) # Затухание со случайной величиной

# Соотношение сигнал/шум

SNR = P_rx / P_n

# Пропускная способность канала связи

cur_C = delta_f * np.log2(1+SNR)

return cur_C*125 # из Мбит в Кбайт

# Получение массивов L, C, V для одного пользователя

def get_user_frame(user_L, n_slots, lmbd):

L_list = []

C_list = []

# Для каждого слота

for k in range(n_slots):

L_list.append([None for i in range(N_rb)])

C_list.append([None for i in range(N_rb)])

# Для каждого ресурсного блока

for j in range(N_rb):

# Генерируем шум со случайной нормальной величиной

L_list[k][j] = user_L + np.random.normal(0,1)

# Считаем максимальную пропускную способность в зависимости от шума

C_list[k][j] = get_C(L_list[k][j])

# Массив с объемом данных, который приходит в каждом слоте

V_list = []

# Для каждого слота генерируем объем данных в кбайт

for k in range(n_slots):

V_list.append(np.random.poisson(lmbd))

return V_list, L_list, C_list

# Алгоритм Maximum Throughput

def maximum_throughput(C_list, V_list):

# Массив с распределением ресурсных блков по пользователям

choice_list = []

# Для каждого слота

for k in range(len(C_list[0])):

choice_list.append([None for j in range(len(C_list[0][0]))])

v_sums = [V_list[u][k] for u in range(len(V_list))]

# Для каждого блока

for j in range(len(C_list[0][0])):

all_c = [C_list[u][k][j] for u in range(len(C_list))]

while v_sums[all_c.index(max(all_c))] < 0:

all_c[all_c.index(max(all_c))] = -1

if sum(all_c) == -1 * len(all_c):

break

choice_list[k][j] = all_c.index(max(all_c))

v_sums[all_c.index(max(all_c))] -= 1

return choice_list

def equal_blind(C_list, V_list):

choice_list = []

num_users = len(V_list)

num_slots = len(C_list[0]) # Число слотов

for k in range(num_slots):

choice_list.append([None for _ in range(N_rb)])

v_sums = [V_list[u][k] for u in range(len(V_list))]

for j in range(N_rb):

if k < 2:

choice_list[k][j] = np.random.choice([i for i in range(num_users)])

else:

r = []

for i in range(num_users):

y_slot = 2

R_interval_start = max(k - y_slot, 0)

R_interval_stop = k

b_list_temp = [[1 if x == i else 0 for x in choice_list[slot]] for slot in range(R_interval_start, R_interval_stop)]

vb_temp = np.array(C_list[i][R_interval_start:R_interval_stop]) * t_rb * np.array(b_list_temp)

r_temp = np.sum(vb_temp) / 1

r.append(r_temp)

p = 1 / np.array(r)

x = np.argmax(p)

choice_list[k][j] = x

if v_sums[x] > 0:

choice_list[k][j] = x

v_sums[x] -= 1

else:

available_users = [i for i in range(num_users) if i not in choice_list[k][:j]]

if available_users:

choice_list[k][j] = np.random.choice(available_users)

else:

choice_list[k][j] = np.random.choice(num_users)

return choice_list

def proportional_fair(C_list, V_list):

choice_list = []

num_users = len(V_list)

num_slots = len(C_list[0])

for k in range(num_slots):

v_sums = [V_list[u][k] for u in range(len(V_list))]

choice_list.append([None for _ in range(N_rb)])

for j in range(N_rb):

if k < 2:

choice_list[k][j] = np.random.choice([i for i in range(num_users)])

else:

r = []

for i in range(num_users):

y_slot = 1

R_interval_start = max(k - y_slot, 0)

R_interval_stop = k

b_list_temp = [[1 if x == i else 0 for x in choice_list[slot]] for slot in range(R_interval_start, R_interval_stop)]

vb_temp = np.array(C_list[i][R_interval_start:R_interval_stop]) * t_rb * np.array(b_list_temp)

r_temp = np.sum(vb_temp) / 1

r.append(r_temp)

p = [C_list[i][k][j] / r_val for i, r_val in enumerate(r)]

x = np.argmax(p)

choice_list[k][j] = x

choice_list[k][j] = x

if v_sums[x] > 0:

choice_list[k][j] = x

v_sums[x] -= 1

else:

available_users = [i for i in range(num_users) if i not in choice_list[k][:j]]

if available_users:

choice_list[k][j] = np.random.choice(available_users)

else:

choice_list[k][j] = np.random.choice(num_users)

return choice_list

def simulate_D(func, lambdas, n_users_list):

D_list_all = [[] for i in range(len(n_users_list))]

V_list_all = [[] for i in range(len(n_users_list))]

for users_index, n_users in enumerate(n_users_list):

print(users_index)

users_L = [get_L(f0, Rmax) for _ in range(n_users)]

for lmbd in lambdas:

V_list = []

L_list = []

C_list = []

for user_L in users_L:

user_V_list, user_L_list, user_C_list = get_user_frame(user_L, 10**2, lmbd)

V_list.append(user_V_list)

L_list.append(user_L_list)

C_list.append(user_C_list)

D_list = [[] for i in range(n_users)]

SUM_list = [[] for i in range(n_users)]

P_list = func(C_list, V_list)

for user_index, user_list in enumerate(V_list):

D_list[user_index] = [None for _ in range(len(V_list[0]))]

SUM_list[user_index] = [None for _ in range(len(V_list[0]))]

for k in range(len(V_list[0])):

if k != 0:

remains = D_list[user_index][k - 1] + V_list[user_index][k] - P_list[k].count(user_index)

remains = remains if remains > 0 else 0

sent = D_list[user_index][k - 1] + V_list[user_index][k] - remains

else:

remains = V_list[user_index][k] - P_list[k].count(user_index)

remains = remains if remains > 0 else 0

sent = 0

D_list[user_index][k] = remains

SUM_list[user_index][k] = sent

V_sums = [sum([SUM_list[u][k] for u in range(n_users) for k in range(len(D_list[0]))])]

D_sums = [sum([D_list[u][n] for u in range(n_users)]) for n in range(len(D_list[0]))]

D_mean = np.mean(D_sums) #/ 1024 / 8

V_mean = np.mean(V_sums) / N_rb

V_mean = V_mean if V_mean > 0 and V_mean < N_rb else N_rb

D_list_all[users_index].append(D_mean)

V_list_all[users_index].append(V_mean)

return D_list_all, V_list_all

# Параметры для симуляции

n_users_list = [2**i for i in range(1, 6)] # Список с количеством абонентов

# lambdas = [i for i in range(0, 100, 20)] # Список lambda - интенсивности входного потока

lambdas = [1, 3, 6, 12, 25]

D_list_all_max, V_list_all_max = simulate_D(maximum_throughput, lambdas, n_users_list)

D_list_all_equal, V_list_all_equal = simulate_D(equal_blind, lambdas, n_users_list)

D_list_all_proportional, V_list_all_proportional = simulate_D(proportional_fair, lambdas, n_users_list)

V_list_all_equal_copy = np.array(V_list_all_equal)

V_list_all_equal_copy[:,0] = 0

V_list_all_equal_copy = list(V_list_all_equal_copy)

V_list_all_max_copy = np.array(V_list_all_max)

V_list_all_max_copy[:,0] = 0

V_list_all_max_copy = list(V_list_all_max_copy)

V_list_all_proportional_copy = np.array(V_list_all_proportional)

V_list_all_proportional_copy[:,0] = 0

V_list_all_proportional_copy = list(V_list_all_proportional_copy)

V_list_all_proportional_copy = 2000*np.array(V_list_all_proportional_copy)

V_list_all_max_copy = 2000*np.array(V_list_all_max_copy)

V_list_all_equal_copy = 2000*np.array(V_list_all_equal_copy)

# Всё на одном графике

plt.figure(figsize=(10, 6))

for i in range(len(V_list_all_max)):

plt.plot(D_list_all_max[i], label=f'Max Trhroughput users 2^{i+1}')

plt.plot(D_list_all_equal[i], label=f'Equal Blind users 2^{i+1}')

plt.plot(D_list_all_proportional[i], label=f'Proportional fair users 2^{i+1}')

plt.legend()

plt.title("Средний суммарный объем данных в буфере от интенсивности входного потока")

plt.xlabel("lmbd")

plt.ylabel("Средний суммарный объем данных в буфере (кбайт)")

plt.legend()

plt.xticks(ticks=np.arange(len(lambdas)),labels=lambdas)

plt.grid(True)

plt.show()

# Для 2^n пользователей

for i in range(len(D_list_all_max)):

plt.plot(D_list_all_max[i], label=f'Max Trhroughput users 2^{i+1}')

plt.plot(D_list_all_equal[i], label=f'Equal Blind users 2^{i+1}')

plt.plot(D_list_all_proportional[i], label=f'Proportional fair users 2^{i+1}')

plt.legend()

plt.xlabel("lmbd")

plt.title("Средний суммарный объем данных в буфере от интенсивности входного потока\n для 2^%s пользователей"%(i+1))

plt.ylabel("Средний суммарный объем данных в буфере (кбайт)")

plt.legend()

plt.xticks(ticks=np.arange(len(lambdas)),labels=lambdas)

plt.grid(True)

plt.show()