diff --git a/module_4_pzc.ipynb b/module_4_pzc.ipynb new file mode 100644 index 0000000..50e2860 --- /dev/null +++ b/module_4_pzc.ipynb @@ -0,0 +1,401 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "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", + "# 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", + " req_addr = API_URL+'/factors/%d'%(n)\n", + " r = requests.get(req_addr )\n", + " if r.status_code > 299:\n", + " logging.error(\"wrong status code from webservice for addr: \" + req_addr )\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)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4.2 - AWS" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "API_URL=\"http://3.219.135.136:8080\"\n", + "UNIT = 60.0 # secs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 36\tmean time: 0.340s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 35\tmean time: 0.350s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.786s\t\n", + "INFO:root:Thread: 0\treqs: 30\tmean time: 0.511s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.712s\t\n", + "INFO:root:Thread: 0\treqs: 29\tmean time: 0.548s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.889s\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.817s\t\n", + "INFO:root:Thread: 0\treqs: 26\tmean time: 0.657s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.956s\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.938s\t\n", + "INFO:root:Thread: 0\treqs: 25\tmean time: 0.770s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 2.001s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 2.030s\t\n", + "INFO:root:Thread: 0\treqs: 23\tmean time: 0.831s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.909s\t\n", + "INFO:root:Thread: 3\treqs: 13\tmean time: 1.813s\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.932s\t\n", + "INFO:root:Thread: 0\treqs: 25\tmean time: 0.760s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.937s\t\n", + "INFO:root:Thread: 4\treqs: 13\tmean time: 1.994s\t\n", + "INFO:root:Thread: 3\treqs: 11\tmean time: 2.218s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 2.252s\t\n", + "INFO:root:Thread: 0\treqs: 17\tmean time: 1.299s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 10\tmean time: 2.651s\t\n", + "INFO:root:Thread: 4\treqs: 11\tmean time: 2.355s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 2.417s\t\n", + "INFO:root:Thread: 2\treqs: 11\tmean time: 2.279s\t\n", + "INFO:root:Thread: 0\treqs: 18\tmean time: 1.201s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 11\tmean time: 2.353s\t\n", + "INFO:root:Thread: 4\treqs: 13\tmean time: 1.812s\t\n", + "INFO:root:Thread: 3\treqs: 14\tmean time: 1.847s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 2.024s\t\n", + "INFO:root:Thread: 0\treqs: 18\tmean time: 1.166s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 12\tmean time: 2.231s\t\n", + "INFO:root:Thread: 4\treqs: 9\tmean time: 2.275s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 2.085s\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.947s\t\n", + "INFO:root:Thread: 0\treqs: 22\tmean time: 0.887s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.960s\t\n", + "INFO:root:Thread: 3\treqs: 6\tmean time: 2.069s\t\n", + "INFO:root:Thread: 2\treqs: 14\tmean time: 1.772s\t\n", + "INFO:root:Thread: 0\treqs: 27\tmean time: 0.657s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.711s\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.708s\t\n", + "INFO:root:Thread: 0\treqs: 32\tmean time: 0.451s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.728s\t\n", + "INFO:root:Thread: 0\treqs: 36\tmean time: 0.338s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 34\tmean time: 0.378s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 36\tmean time: 0.334s\tfast\t\n" + ] + } + ], + "source": [ + "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": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import scipy.stats as stats\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def plot():\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.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4.1 - Hetzner" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "API_URL=\"http://95.217.175.98:8080\"\n", + "UNIT = 5.0 # secs" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.243s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.160s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.580s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.585s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.512s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.289s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.451s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.323s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.550s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.738s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.642s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.370s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.457s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.997s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.158s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.973s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 2\tmean time: 2.063s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.384s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.721s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 3.673s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.371s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 3.717s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.469s\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 3.726s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 3.833s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.686s\t\n", + "INFO:root:Thread: 0\treqs: 1\tmean time: 2.421s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 2.063s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.196s\t\n", + "INFO:root:Thread: 3\treqs: 2\tmean time: 1.929s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.539s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.196s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 1.531s\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 1.502s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.389s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.177s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.160s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 1\tmean time: 0.254s\tfast\t\n" + ] + } + ], + "source": [ + "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": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}