diff --git a/load-balancer/test.ipynb b/load-balancer/test.ipynb index e69de29..fba06bf 100644 --- a/load-balancer/test.ipynb +++ b/load-balancer/test.ipynb @@ -0,0 +1,276 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: requests in /home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/lib/python3.9/site-packages (2.28.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/lib/python3.9/site-packages (from requests) (3.0.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/lib/python3.9/site-packages (from requests) (2022.12.7)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/lib/python3.9/site-packages (from requests) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/lib/python3.9/site-packages (from requests) (1.26.14)\n", + "\u001b[33mWARNING: You are using pip version 22.0.4; however, version 22.3.1 is available.\n", + "You should consider upgrading via the '/home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/bin/python -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n", + "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.192s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.178s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.489s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.523s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.755s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.824s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.823s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.610s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.086s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.465s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.584s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.565s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 2.151s\t\n", + "INFO:root:Thread: 3\treqs: 2\tmean time: 1.598s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 2.198s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.863s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 2.258s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 2.775s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.154s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.530s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.278s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.543s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.730s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 3.747s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.123s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 4.172s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.420s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.872s\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 4.077s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.762s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.906s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.707s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.576s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.447s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.205s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.190s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.200s\tfast\t\n" + ] + } + ], + "source": [ + "%pip install requests\n", + "import requests\n", + "import random\n", + "import math\n", + "import time\n", + "import threading\n", + "import logging\n", + "logging.getLogger().setLevel(logging.INFO)\n", + "\n", + "\n", + "API_URL=\"http://65.109.40.56:80\"\n", + "\n", + "\n", + "UNIT = 5.0 # secs\n", + "\n", + "# Pre generated primes\n", + "first_primes_list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,\n", + " 31, 37, 41, 43, 47, 53, 59, 61, 67,\n", + " 71, 73, 79, 83, 89, 97, 101, 103,\n", + " 107, 109, 113, 127, 131, 137, 139,\n", + " 149, 151, 157, 163, 167, 173, 179,\n", + " 181, 191, 193, 197, 199, 211, 223,\n", + " 227, 229, 233, 239, 241, 251, 257,\n", + " 263, 269, 271, 277, 281, 283, 293,\n", + " 307, 311, 313, 317, 331, 337, 347, 349]\n", + "\n", + "\n", + "def nBitRandom(n):\n", + " return random.randrange(2**(n-1)+1, 2**n - 1)\n", + " \n", + "def getLowLevelPrime(n):\n", + " '''Generate a prime candidate divisible\n", + " by first primes'''\n", + " while True:\n", + " # Obtain a random number\n", + " pc = nBitRandom(n)\n", + " \n", + " # Test divisibility by pre-generated\n", + " # primes\n", + " for divisor in first_primes_list:\n", + " if pc % divisor == 0 and divisor**2 <= pc:\n", + " break\n", + " else: return pc\n", + " \n", + "def isMillerRabinPassed(mrc):\n", + " '''Run 20 iterations of Rabin Miller Primality test'''\n", + " maxDivisionsByTwo = 0\n", + " ec = mrc-1\n", + " while ec % 2 == 0:\n", + " ec >>= 1\n", + " maxDivisionsByTwo += 1\n", + " assert(2**maxDivisionsByTwo * ec == mrc-1)\n", + " \n", + " def trialComposite(round_tester):\n", + " if pow(round_tester, ec, mrc) == 1:\n", + " return False\n", + " for i in range(maxDivisionsByTwo):\n", + " if pow(round_tester, 2**i * ec, mrc) == mrc-1:\n", + " return False\n", + " return True\n", + " \n", + " # Set number of trials here\n", + " numberOfRabinTrials = 20\n", + " for i in range(numberOfRabinTrials):\n", + " round_tester = random.randrange(2, mrc)\n", + " if trialComposite(round_tester):\n", + " return False\n", + " return True\n", + " \n", + "def random_large_prime(bits):\n", + " while True:\n", + " prime_candidate = getLowLevelPrime(bits)\n", + " if not isMillerRabinPassed(prime_candidate):\n", + " continue\n", + " else:\n", + " return prime_candidate\n", + "\n", + "def thread_function(i, fast, timeout):\n", + " start = time.time()\n", + "\n", + " c = 5 # bits: 20: 200ms; 21: 350ms; 22: 700ms 23: 1.5s; 25: 6s; 26: 10s; 27: 24s\n", + " bits = 19 if fast else 23\n", + " last_report = time.time()\n", + " processing_time = 0.0\n", + " reqs = 0\n", + " while True:\n", + " iter_start = time.time()\n", + " if iter_start - start > timeout:\n", + " logging.info(\"Thread: %d\\treqs: %d\\tmean time: %.3fs\\t%s\"%(i, reqs, processing_time/reqs if reqs>0 else 0.0, \"fast\\t\" if fast else \"\"))\n", + " results[i][iter_start] = processing_time/reqs if reqs>0 else 0.0\n", + " return\n", + " if iter_start - last_report > UNIT/2:\n", + " if len(results[i])%2 == 0:\n", + " logging.info(\"Thread: %d\\treqs: %d\\tmean time: %.3fs\\t%s\"%(i, reqs, processing_time/reqs if reqs>0 else 0.0, \"fast\\t\" if fast else \"\"))\n", + " results[i][iter_start] = processing_time/reqs if reqs>0 else 0.0\n", + " processing_time = 0.0\n", + " reqs = 0\n", + " last_report=iter_start\n", + "\n", + " factors = [random_large_prime(bits) for i in range(c)]\n", + " factors.sort()\n", + " n=math.prod(factors)\n", + "\n", + " r = requests.get(API_URL+'/factors/%d'%(n))\n", + " if r.status_code != 200:\n", + " logging.error(\"wrong status code from webservice\")\n", + " else:\n", + " result = r.json()\n", + " if result != factors:\n", + " logging.error(\"Wrong factors\")\n", + "\n", + " processing_time+=time.time() - iter_start\n", + " reqs+=1\n", + " time.sleep(0.5)\n", + "\n", + "START = time.time()\n", + "slow_threads = 4\n", + "\n", + "results = [ {} for i in range(slow_threads+1)]\n", + "\n", + "t0 = threading.Thread(target=thread_function, args=(0, True, (5 + slow_threads*3) * UNIT))\n", + "t0.start()\n", + "time.sleep(2 * UNIT)\n", + "for i in range(slow_threads):\n", + " t = threading.Thread(target=thread_function, args=(i+1, False, (slow_threads-i) * 3 * UNIT))\n", + " t.start()\n", + " time.sleep(2 * UNIT)\n", + "\n", + "t0.join()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: You are using pip version 22.0.4; however, version 22.3.1 is available.\n", + "You should consider upgrading via the '/home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/bin/python -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n", + "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n", + "\u001b[33mWARNING: You are using pip version 22.0.4; however, version 22.3.1 is available.\n", + "You should consider upgrading via the '/home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/bin/python -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n", + "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n", + "\u001b[33mWARNING: You are using pip version 22.0.4; however, version 22.3.1 is available.\n", + "You should consider upgrading via the '/home/kuba/uam/sem2/chmura/Hetzner/code-server/hetz_gitea_venv/bin/python -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n", + "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%pip install numpy --quiet\n", + "%pip install matplotlib --quiet\n", + "%pip install scipy --quiet\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.stats as stats\n", + "mu = 0\n", + "std = 1\n", + "for i, result in enumerate(results):\n", + " x = [(x - START)/UNIT for x in result.keys()]\n", + " y = result.values()\n", + " plt.plot(x, y, label=\"t%d\"%(i,))\n", + "\n", + "plt.legend()\n", + "plt.savefig('load-balancer.png')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "hetz_gitea_venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "d3d864e1be7564ec15be68b6f80dea10522185afad36544549c9f900b3e93631" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}