davydov_yuriy_lab_5

davydov_yuriy_lab_4/Consumer_1.py

@@ -0,0 +1,25 @@
+import random
+import time
+import pika
+
+queue_name = 'first_queue'
+exchange = 'logs'
+
+
+def callback(ch, method, properties, body):
+    print(f" Consumer_1: было получено сообщение {body.decode()}")
+    time.sleep(random.choice([2, 3]))
+    print(f" Consumer_1: было обработано сообщение")
+    ch.basic_ack(delivery_tag=method.delivery_tag)
+
+
+if __name__ == '__main__':
+    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
+    channel = connection.channel()
+    try:
+        channel.queue_declare(queue=queue_name) #queue
+        channel.queue_bind(exchange=exchange, queue=queue_name) #binding
+        channel.basic_consume(queue=queue_name, on_message_callback=callback)
+        channel.start_consuming()
+    except KeyboardInterrupt:
+        connection.close()

davydov_yuriy_lab_4/Consumer_2.py

@@ -0,0 +1,22 @@
+import pika
+
+queue_name = 'second_queue'
+exchange = 'logs'
+
+
+def callback(ch, method, properties, body):
+    print(f" Consumer_2: было получено сообщение {body.decode()}")
+    print(f" Consumer_2: было обработано сообщение")
+    ch.basic_ack(delivery_tag=method.delivery_tag)
+
+
+if __name__ == '__main__':
+    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
+    channel = connection.channel()
+    try:
+        channel.queue_declare(queue=queue_name) #queue
+        channel.queue_bind(exchange=exchange, queue=queue_name) #binding
+        channel.basic_consume(queue=queue_name, on_message_callback=callback)
+        channel.start_consuming()
+    except KeyboardInterrupt:
+        connection.close()

davydov_yuriy_lab_4/Publisher.py

@@ -0,0 +1,18 @@
+import random
+import time
+import pika
+
+if __name__ == '__main__':
+    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
+    channel = connection.channel()
+    channel.exchange_declare(exchange='logs', exchange_type='fanout')
+
+    try:
+        while True:
+            message = random.choice(["Необходимо подать заявление на поступление", "Обновлена информация о факультетах",
+                                     "Обновлена информация о специальностях", "Изменение в конкурсных списках", "Начат доприем",
+                                     "Приемная комиссия закрывается"])
+            channel.basic_publish(exchange='logs', routing_key='', body=message)
+            time.sleep(1)
+    except KeyboardInterrupt:
+        connection.close()

davydov_yuriy_lab_4/README.md

@@ -0,0 +1,19 @@
+# Лабораторная работа №4 - Работа с брокером сообщений
+
+## ПИбд-42 || Давыдов Юрий
+
+### Цель лабораторной работы
+
+Изучение проектирования приложений с использованием брокера сообщений.
+
+Описание задач 1-2:
+В ходе данной лабораторной работы был установлен брокер сообщений RabbitMQ. Затем для обучения были выполнены первые три урока из RabbitMQ Tutorials с использованием языка программирования Python.
+
+Предметная область:
+Предметная область, использованная в этой лабораторной работе, совпадает с предыдущей — списки абитуриентов для поступления в университет.
+
+Описание задачи 3:
+Далее в рамках лабораторной работы были разработаны демонстрационные приложения Publisher, Consumer_1 и Consumer_2, связанные с указанной предметной областью.
+
+Выводы:
+Анализ данных показывает, что очередь second_queue не заполняется, поскольку сообщения в этой очереди обрабатываются мгновенно, и они не задерживаются. В то время как Consumer_1 требует 2-3 секунды для обработки одного сообщения, что приводит к быстрому заполнению очереди first_queue, если запущен только один экземпляр. Также было замечено, что с увеличением числа экземпляров Consumer_1 очередь заполняется медленнее. Это связано с тем, что каждый экземпляр обрабатывает сообщения из очереди. При увеличении числа экземпляров можно достичь ситуации, когда очередь перестанет заполняться.

davydov_yuriy_lab_4/lesson_1/receive.py

@@ -0,0 +1,25 @@
+import pika, sys, os
+
+def main():
+    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
+    channel = connection.channel()
+
+    channel.queue_declare(queue='hello')
+
+    def callback(ch, method, properties, body):
+        print(f" [x] Received {body}")
+
+    channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)
+
+    print(' [*] Waiting for messages. To exit press CTRL+C')
+    channel.start_consuming()
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        print('Interrupted')
+        try:
+            sys.exit(0)
+        except SystemExit:
+            os._exit(0)

davydov_yuriy_lab_4/lesson_1/send.py

@@ -0,0 +1,11 @@
+import pika
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.queue_declare(queue='hello')
+
+channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
+print(" [x] Sent 'Hello World!'")
+connection.close()

davydov_yuriy_lab_4/lesson_2/new_task.py

@@ -0,0 +1,19 @@
+import pika
+import sys
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.queue_declare(queue='task_queue', durable=True)
+
+message = ' '.join(sys.argv[1:]) or "Hello World!"
+channel.basic_publish(
+    exchange='',
+    routing_key='task_queue',
+    body=message,
+    properties=pika.BasicProperties(
+        delivery_mode=pika.DeliveryMode.Persistent
+    ))
+print(f" [x] Sent {message}")
+connection.close()

davydov_yuriy_lab_4/lesson_2/worker.py

@@ -0,0 +1,22 @@
+import pika
+import time
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.queue_declare(queue='task_queue', durable=True)
+print(' [*] Waiting for messages. To exit press CTRL+C')
+
+
+def callback(ch, method, properties, body):
+    print(f" [x] Received {body.decode()}")
+    time.sleep(body.count(b'.'))
+    print(" [x] Done")
+    ch.basic_ack(delivery_tag=method.delivery_tag)
+
+
+channel.basic_qos(prefetch_count=1)
+channel.basic_consume(queue='task_queue', on_message_callback=callback)
+
+channel.start_consuming()

davydov_yuriy_lab_4/lesson_3/emit_log.py

@@ -0,0 +1,13 @@
+import pika
+import sys
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.exchange_declare(exchange='logs', exchange_type='fanout')
+
+message = ' '.join(sys.argv[1:]) or "info: Hello World!"
+channel.basic_publish(exchange='logs', routing_key='', body=message)
+print(f" [x] Sent {message}")
+connection.close()

davydov_yuriy_lab_4/lesson_3/receive_logs.py

@@ -0,0 +1,22 @@
+import pika
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.exchange_declare(exchange='logs', exchange_type='fanout')
+
+result = channel.queue_declare(queue='', exclusive=True)
+queue_name = result.method.queue
+
+channel.queue_bind(exchange='logs', queue=queue_name)
+
+print(' [*] Waiting for logs. To exit press CTRL+C')
+
+def callback(ch, method, properties, body):
+    print(f" [x] {body}")
+
+channel.basic_consume(
+    queue=queue_name, on_message_callback=callback, auto_ack=True)
+
+channel.start_consuming()

davydov_yuriy_lab_5/README.md

@@ -0,0 +1,10 @@
+# Лабораторная работа №5 - Параллельное перемножение матриц
+
+## ПИбд-42 || Давыдов Юрий
+
+### Цель лабораторной работы
+
+Изучение принципов параллельных вычислений, а также определение случаев, когда их использование оправдано, а когда — нет.
+
+Описание:
+Был реализован механизм параллельного умножения матриц размером 100x100, 300x300 и 500x500 с возможностью задания количества потоков, включая один поток (для последовательного умножения). Были произведены замеры времени для каждого вычисления, проведен анализ результатов и сделаны соответствующие выводы.

davydov_yuriy_lab_5/main.py

@@ -0,0 +1,59 @@
+import random
+import time
+import multiprocessing
+import numpy as np
+
+# Генерация случайной матрицы
+def create_random_matrix(dim):
+    return [[random.randint(0, 10) for _ in range(dim)] for _ in range(dim)]
+
+# Умножение отдельной строки
+def compute_row_product(row_idx, mat_a, mat_b, output_mat):
+    dim = len(mat_a)
+    for col_idx in range(dim):
+        for k in range(dim):
+            output_mat[row_idx][col_idx] += mat_a[row_idx][k] * mat_b[k][col_idx]
+
+# Параллельное умножение матриц
+def parallel_matrix_multiplication(mat_a, mat_b, num_workers):
+    dim = len(mat_a)
+    result_matrix = [[0] * dim for _ in range(dim)]
+    
+    with multiprocessing.Pool(processes=num_workers) as pool:
+        pool.starmap(compute_row_product, [(i, mat_a, mat_b, result_matrix) for i in range(dim)])
+    
+    return result_matrix
+
+# Измерение времени выполнения
+def run_benchmark(dim, num_workers=1):
+    mat_a = create_random_matrix(dim)
+    mat_b = create_random_matrix(dim)
+
+    start_time = time.time()
+    parallel_matrix_multiplication(mat_a, mat_b, num_workers)
+    elapsed_time = time.time() - start_time
+
+    return elapsed_time
+
+def main():
+    # Размеры матриц
+    matrix_dimensions = [100, 300, 500]  
+    # Количество рабочих процессов
+    worker_counts = [1, 2, 4, 6, 8]
+    
+    # Печать таблицы с результатами
+    print("-*" * 40)
+    print(f"{'Количество процессов':<20}{'|100x100 (сек.)':<20}{'|300x300 (сек.)':<20}{'|500x500 (сек.)'}")
+    print("-*" * 40)
+    
+    for workers in worker_counts:
+        row = f"{workers:<20}"
+        
+        for dim in matrix_dimensions:
+            benchmark_time = run_benchmark(dim, workers)
+            row += f"|{benchmark_time:.4f}".ljust(20)
+        print(row)
+        print("-*" * 40)
+
+if __name__ == "__main__":
+    main()