From ebcdad41fc137da8515b452c5ab49642d7643d7a Mon Sep 17 00:00:00 2001 From: AWieczarek Date: Tue, 17 Dec 2024 21:43:30 +0100 Subject: [PATCH] Added solution with tests --- .env.example | 3 + aws_4.py | 198 ++++++++ tester.ipynb | 1215 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1416 insertions(+) create mode 100644 .env.example create mode 100644 aws_4.py create mode 100644 tester.ipynb diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..e1fd951 --- /dev/null +++ b/.env.example @@ -0,0 +1,3 @@ +AWS_ACCESS_KEY_ID= +AWS_SECRET_ACCESS_KEY= +AWS_SESSION_TOKEN= diff --git a/aws_4.py b/aws_4.py new file mode 100644 index 0000000..70b1770 --- /dev/null +++ b/aws_4.py @@ -0,0 +1,198 @@ +import boto3 +import base64 +from dotenv import load_dotenv +import os + +load_dotenv() + +PREFIX = "464979" +REGION = "us-east-1" +AMI_ID = "ami-0b5eea76982371e91" +REPO_URL = "https://git.wmi.amu.edu.pl/s464979/chmury-aws.git" +INSTANCE_TYPE = "t2.micro" + +aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID") +aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY") +aws_session_token = os.getenv("AWS_SESSION_TOKEN") + +user_data_script = f"""#!/bin/bash +sudo yum update -y +sudo yum install -y git +cd /home/ec2-user +git clone {REPO_URL} +cd chmury-aws +chmod +x webservice +./webservice +""" + +ec2_client = boto3.client( + 'ec2', + region_name=REGION, + aws_access_key_id=aws_access_key_id, + aws_secret_access_key=aws_secret_access_key, + aws_session_token=aws_session_token, +) + +elbv2 = boto3.client( + 'elbv2', + region_name=REGION, + aws_access_key_id=aws_access_key_id, + aws_secret_access_key=aws_secret_access_key, + aws_session_token=aws_session_token, +) + +autoscaling = boto3.client( + 'autoscaling', + region_name=REGION, + aws_access_key_id=aws_access_key_id, + aws_secret_access_key=aws_secret_access_key, + aws_session_token=aws_session_token, +) + +cloudwatch = boto3.client( + 'cloudwatch', + region_name=REGION, + aws_access_key_id=aws_access_key_id, + aws_secret_access_key=aws_secret_access_key, + aws_session_token=aws_session_token, +) + +vpc_cidr = '10.0.0.0/16' +vpc_response = ec2_client.create_vpc(CidrBlock=vpc_cidr) +vpc_id = vpc_response['Vpc']['VpcId'] +ec2_client.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={'Value': True}) +ec2_client.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={'Value': True}) +ec2_client.create_tags(Resources=[vpc_id], Tags=[{'Key': 'Name', 'Value': PREFIX + '-vpc'}]) + +ig_response = ec2_client.create_internet_gateway() +ig_id = ig_response['InternetGateway']['InternetGatewayId'] +ec2_client.attach_internet_gateway(InternetGatewayId=ig_id, VpcId=vpc_id) + +subnet_cidr = '10.0.1.0/24' +subnet_response = ec2_client.create_subnet(CidrBlock=subnet_cidr, VpcId=vpc_id) +subnet_id = subnet_response['Subnet']['SubnetId'] +ec2_client.modify_subnet_attribute(SubnetId=subnet_id, MapPublicIpOnLaunch={'Value': True}) +ec2_client.create_tags(Resources=[subnet_id], Tags=[{'Key': 'Name', 'Value': PREFIX + '-subnet'}]) + +rt_response = ec2_client.create_route_table(VpcId=vpc_id) +rt_id = rt_response['RouteTable']['RouteTableId'] +ec2_client.create_route(RouteTableId=rt_id, DestinationCidrBlock='0.0.0.0/0', GatewayId=ig_id) +ec2_client.associate_route_table(RouteTableId=rt_id, SubnetId=subnet_id) + +key_pair = ec2_client.create_key_pair(KeyName=PREFIX + '-key', KeyType='ed25519') + +sg_response = ec2_client.create_security_group( + Description=PREFIX + '-sg', + GroupName=PREFIX + '-sg', + VpcId=vpc_id +) +sg_id = sg_response['GroupId'] + +ec2_client.authorize_security_group_ingress( + GroupId=sg_id, + IpPermissions=[{ + 'IpProtocol': 'tcp', + 'FromPort': 8080, + 'ToPort': 8080, + 'IpRanges': [{'CidrIp': '0.0.0.0/0'}] + }] +) + +tg_response = elbv2.create_target_group( + Name=PREFIX + '-TargetGroup', + Protocol='TCP', + Port=8080, + VpcId=vpc_id, + TargetType='instance', + IpAddressType='ipv4', +) +tg_arn = tg_response['TargetGroups'][0]['TargetGroupArn'] + +alloc_response = ec2_client.allocate_address(Domain='vpc') +allocation_id = alloc_response['AllocationId'] + +nlb_response = elbv2.create_load_balancer( + Name=PREFIX + '-LoadBalancer', + SubnetMappings=[{'SubnetId': subnet_id, 'AllocationId': allocation_id}], + Scheme='internet-facing', + Type='network', + IpAddressType='ipv4', +) +lb_arn = nlb_response['LoadBalancers'][0]['LoadBalancerArn'] +lb_dns = nlb_response['LoadBalancers'][0]['DNSName'] + +elbv2.create_listener( + LoadBalancerArn=lb_arn, + Protocol='TCP', + Port=8080, + DefaultActions=[{ + 'Type': 'forward', + 'TargetGroupArn': tg_arn, + }], +) + +lt_response = ec2_client.create_launch_template( + LaunchTemplateName=PREFIX + '-LT', + LaunchTemplateData={ + 'ImageId': AMI_ID, + 'InstanceType': INSTANCE_TYPE, + 'KeyName': PREFIX + '-key', + 'SecurityGroupIds': [sg_id], + 'UserData': base64.b64encode(user_data_script.encode('utf-8')).decode('utf-8'), + } +) + +asg_name = PREFIX + '-ASG' +autoscaling.create_auto_scaling_group( + AutoScalingGroupName=asg_name, + LaunchTemplate={ + 'LaunchTemplateId': lt_response['LaunchTemplate']['LaunchTemplateId'], + 'Version': '$Latest' + }, + MinSize=2, + MaxSize=5, + DesiredCapacity=2, + VPCZoneIdentifier=subnet_id, + TargetGroupARNs=[tg_arn], + HealthCheckType='EC2', + HealthCheckGracePeriod=90, + Tags=[ + { + 'Key': 'Name', + 'Value': PREFIX + '-instance', + 'PropagateAtLaunch': True + } + ] +) + +scale_out_response = autoscaling.put_scaling_policy( + AutoScalingGroupName=asg_name, + PolicyName= PREFIX + '-ScaleOutPolicy', + PolicyType='SimpleScaling', + AdjustmentType='ChangeInCapacity', + ScalingAdjustment=1, + Cooldown=180 +) +scale_out_policy_arn = scale_out_response['PolicyARN'] + +cloudwatch.put_metric_alarm( + AlarmName= PREFIX + '-HighCPU-Alarm', + ComparisonOperator='GreaterThanThreshold', + EvaluationPeriods=2, + MetricName='CPUUtilization', + Namespace='AWS/EC2', + Period=60, + Statistic='Average', + Threshold=30.0, # Zmienić jeśli potrzeba późniejszego skalowania + ActionsEnabled=True, + AlarmActions=[scale_out_policy_arn], + Dimensions=[ + { + 'Name': 'AutoScalingGroupName', + 'Value': asg_name + }, + ], + Unit='Percent' +) + +print(f"Load Balancer DNS: {lb_dns}") diff --git a/tester.ipynb b/tester.ipynb new file mode 100644 index 0000000..3a699e4 --- /dev/null +++ b/tester.ipynb @@ -0,0 +1,1215 @@ +{ + "cells": [ + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Dwie instancje - 5s", + "id": "26ad0da599026613" + }, + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2024-12-12T19:50:47.681398Z", + "start_time": "2024-12-12T19:49:22.595934Z" + } + }, + "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", + "\n", + "API_URL=\"http://464979-loadbalancer-af7b87d5a8a2b254.elb.us-east-1.amazonaws.com:8080\"\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()" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.310s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.291s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.264s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 0.807s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.192s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 0.889s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.207s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.014s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.276s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.217s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.238s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.830s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.373s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.577s\t\n", + "INFO:root:Thread: 3\treqs: 2\tmean time: 1.599s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.513s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 2.082s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.520s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 3.425s\t\n", + "INFO:root:Thread: 3\treqs: 2\tmean time: 1.823s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.838s\t\n", + "INFO:root:Thread: 4\treqs: 2\tmean time: 2.551s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 2.324s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.642s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.553s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 3.185s\t\n", + "INFO:root:Thread: 0\treqs: 1\tmean time: 2.372s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.471s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.447s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.549s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.468s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.369s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.088s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.315s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.319s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.293s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.292s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 1\tmean time: 0.304s\tfast\t\n" + ] + } + ], + "execution_count": 5 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-12T19:50:47.854365Z", + "start_time": "2024-12-12T19:50:47.688366Z" + } + }, + "cell_type": "code", + "source": [ + "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.show()" + ], + "id": "769f1da39d2be428", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Dwie instancje - 60s", + "id": "48befdffa20b83d7" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-12T22:01:25.529006Z", + "start_time": "2024-12-12T21:44:25.216553Z" + } + }, + "cell_type": "code", + "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", + "\n", + "API_URL=\"http://464979-1-LoadBalancer-69cc70eab93f0b76.elb.us-east-1.amazonaws.com:8080\"\n", + "\n", + "\n", + "UNIT = 60.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()" + ], + "id": "fe96b6b86f45c601", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.298s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.296s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 18\tmean time: 1.230s\t\n", + "INFO:root:Thread: 0\treqs: 24\tmean time: 0.787s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 18\tmean time: 1.196s\t\n", + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.624s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 17\tmean time: 1.314s\t\n", + "INFO:root:Thread: 1\treqs: 17\tmean time: 1.358s\t\n", + "INFO:root:Thread: 0\treqs: 25\tmean time: 0.732s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 17\tmean time: 1.290s\t\n", + "INFO:root:Thread: 1\treqs: 17\tmean time: 1.292s\t\n", + "INFO:root:Thread: 0\treqs: 26\tmean time: 0.714s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 14\tmean time: 1.792s\t\n", + "INFO:root:Thread: 2\treqs: 15\tmean time: 1.542s\t\n", + "INFO:root:Thread: 1\treqs: 15\tmean time: 1.573s\t\n", + "INFO:root:Thread: 0\treqs: 17\tmean time: 1.279s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 15\tmean time: 1.578s\t\n", + "INFO:root:Thread: 2\treqs: 14\tmean time: 1.649s\t\n", + "INFO:root:Thread: 1\treqs: 15\tmean time: 1.591s\t\n", + "INFO:root:Thread: 0\treqs: 20\tmean time: 1.126s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 11\tmean time: 2.223s\t\n", + "INFO:root:Thread: 3\treqs: 13\tmean time: 1.831s\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.851s\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.657s\t\n", + "INFO:root:Thread: 0\treqs: 15\tmean time: 1.573s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 12\tmean time: 2.031s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 2.097s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 2.049s\t\n", + "INFO:root:Thread: 1\treqs: 11\tmean time: 2.243s\t\n", + "INFO:root:Thread: 0\treqs: 17\tmean time: 1.269s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 13\tmean time: 1.867s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 1.995s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 2.199s\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.719s\t\n", + "INFO:root:Thread: 0\treqs: 14\tmean time: 1.665s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 11\tmean time: 1.911s\t\n", + "INFO:root:Thread: 3\treqs: 14\tmean time: 1.737s\t\n", + "INFO:root:Thread: 2\treqs: 14\tmean time: 1.723s\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.649s\t\n", + "INFO:root:Thread: 0\treqs: 18\tmean time: 1.172s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 10\tmean time: 1.455s\t\n", + "INFO:root:Thread: 2\treqs: 17\tmean time: 1.333s\t\n", + "INFO:root:Thread: 1\treqs: 17\tmean time: 1.372s\t\n", + "INFO:root:Thread: 0\treqs: 23\tmean time: 0.870s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 7\tmean time: 1.359s\t\n", + "INFO:root:Thread: 0\treqs: 30\tmean time: 0.498s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 18\tmean time: 1.208s\t\n", + "INFO:root:Thread: 1\treqs: 5\tmean time: 1.212s\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.296s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.295s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.296s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 5\tmean time: 0.295s\tfast\t\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-12T22:01:26.803013Z", + "start_time": "2024-12-12T22:01:26.661011Z" + } + }, + "cell_type": "code", + "source": [ + "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.show()" + ], + "id": "137da80ee1917887", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Skalowanie bez odczekania - 45s", + "id": "cfc4f63a6d75d706" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-15T12:18:13.889672Z", + "start_time": "2024-12-15T12:05:28.613196Z" + } + }, + "cell_type": "code", + "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", + "\n", + "API_URL=\"http://464979-LoadBalancer-272a50d718ade55d.elb.us-east-1.amazonaws.com:8080\"\n", + "\n", + "\n", + "UNIT = 45.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()" + ], + "id": "ccc64a8d2cd6f5aa", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.297s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.299s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 23\tmean time: 0.477s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.274s\t\n", + "INFO:root:Thread: 0\treqs: 23\tmean time: 0.503s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.211s\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.349s\t\n", + "INFO:root:Thread: 0\treqs: 20\tmean time: 0.642s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.374s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 1.442s\t\n", + "INFO:root:Thread: 0\treqs: 16\tmean time: 0.900s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 12\tmean time: 1.411s\t\n", + "INFO:root:Thread: 3\treqs: 9\tmean time: 1.992s\t\n", + "INFO:root:Thread: 0\treqs: 17\tmean time: 0.848s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 10\tmean time: 1.906s\t\n", + "INFO:root:Thread: 1\treqs: 12\tmean time: 1.553s\t\n", + "INFO:root:Thread: 3\treqs: 10\tmean time: 1.784s\t\n", + "INFO:root:Thread: 0\treqs: 18\tmean time: 0.804s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 1.586s\t\n", + "INFO:root:Thread: 1\treqs: 11\tmean time: 1.549s\t\n", + "INFO:root:Thread: 4\treqs: 11\tmean time: 1.740s\t\n", + "INFO:root:Thread: 3\treqs: 9\tmean time: 2.065s\t\n", + "INFO:root:Thread: 0\treqs: 12\tmean time: 1.411s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 11\tmean time: 1.740s\t\n", + "INFO:root:Thread: 1\treqs: 10\tmean time: 1.989s\t\n", + "INFO:root:Thread: 3\treqs: 9\tmean time: 1.999s\t\n", + "INFO:root:Thread: 4\treqs: 11\tmean time: 1.749s\t\n", + "INFO:root:Thread: 0\treqs: 12\tmean time: 1.435s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 9\tmean time: 2.036s\t\n", + "INFO:root:Thread: 1\treqs: 10\tmean time: 1.991s\t\n", + "INFO:root:Thread: 3\treqs: 11\tmean time: 1.751s\t\n", + "INFO:root:Thread: 4\treqs: 10\tmean time: 1.978s\t\n", + "INFO:root:Thread: 0\treqs: 16\tmean time: 0.951s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 11\tmean time: 1.589s\t\n", + "INFO:root:Thread: 1\treqs: 9\tmean time: 2.112s\t\n", + "INFO:root:Thread: 4\treqs: 7\tmean time: 1.789s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 1.455s\t\n", + "INFO:root:Thread: 2\treqs: 10\tmean time: 1.824s\t\n", + "INFO:root:Thread: 0\treqs: 18\tmean time: 0.825s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 7\tmean time: 1.603s\t\n", + "INFO:root:Thread: 1\treqs: 12\tmean time: 1.409s\t\n", + "INFO:root:Thread: 0\treqs: 24\tmean time: 0.437s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.322s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.131s\t\n", + "INFO:root:Thread: 1\treqs: 13\tmean time: 1.296s\t\n", + "INFO:root:Thread: 0\treqs: 25\tmean time: 0.406s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 10\tmean time: 1.272s\t\n", + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.300s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.298s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.296s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 1\tmean time: 0.287s\tfast\t\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-15T12:18:15.017610Z", + "start_time": "2024-12-15T12:18:13.905578Z" + } + }, + "cell_type": "code", + "source": [ + "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.show()" + ], + "id": "8efd3f7f8448156", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Skalowanie z odczekaniem - 60s", + "id": "3e9cf6b37d5768d2" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-16T18:43:04.722472Z", + "start_time": "2024-12-16T18:26:04.487945Z" + } + }, + "cell_type": "code", + "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", + "\n", + "API_URL=\"http://464979-LoadBalancer-0165784e7aab6ce5.elb.us-east-1.amazonaws.com:8080\"\n", + "\n", + "\n", + "UNIT = 60.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()" + ], + "id": "1f32ef0d5d8c5253", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.295s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.297s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 18\tmean time: 1.198s\t\n", + "INFO:root:Thread: 0\treqs: 28\tmean time: 0.591s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 17\tmean time: 1.272s\t\n", + "INFO:root:Thread: 0\treqs: 27\tmean time: 0.619s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 18\tmean time: 1.263s\t\n", + "INFO:root:Thread: 1\treqs: 17\tmean time: 1.281s\t\n", + "INFO:root:Thread: 0\treqs: 26\tmean time: 0.689s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 16\tmean time: 1.433s\t\n", + "INFO:root:Thread: 1\treqs: 16\tmean time: 1.415s\t\n", + "INFO:root:Thread: 0\treqs: 27\tmean time: 0.628s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 14\tmean time: 1.734s\t\n", + "INFO:root:Thread: 2\treqs: 16\tmean time: 1.501s\t\n", + "INFO:root:Thread: 1\treqs: 16\tmean time: 1.449s\t\n", + "INFO:root:Thread: 0\treqs: 17\tmean time: 1.343s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 15\tmean time: 1.594s\t\n", + "INFO:root:Thread: 2\treqs: 15\tmean time: 1.500s\t\n", + "INFO:root:Thread: 0\treqs: 21\tmean time: 0.930s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 16\tmean time: 1.477s\t\n", + "INFO:root:Thread: 4\treqs: 13\tmean time: 1.995s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 2.077s\t\n", + "INFO:root:Thread: 2\treqs: 12\tmean time: 2.025s\t\n", + "INFO:root:Thread: 1\treqs: 11\tmean time: 2.229s\t\n", + "INFO:root:Thread: 0\treqs: 16\tmean time: 1.446s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 13\tmean time: 1.815s\t\n", + "INFO:root:Thread: 3\treqs: 13\tmean time: 2.048s\t\n", + "INFO:root:Thread: 2\treqs: 11\tmean time: 2.350s\t\n", + "INFO:root:Thread: 1\treqs: 11\tmean time: 2.351s\t\n", + "INFO:root:Thread: 0\treqs: 15\tmean time: 1.567s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 15\tmean time: 1.561s\t\n", + "INFO:root:Thread: 3\treqs: 12\tmean time: 2.006s\t\n", + "INFO:root:Thread: 2\treqs: 13\tmean time: 1.966s\t\n", + "INFO:root:Thread: 1\treqs: 14\tmean time: 1.681s\t\n", + "INFO:root:Thread: 0\treqs: 20\tmean time: 1.038s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 13\tmean time: 1.568s\t\n", + "INFO:root:Thread: 3\treqs: 17\tmean time: 1.359s\t\n", + "INFO:root:Thread: 2\treqs: 15\tmean time: 1.510s\t\n", + "INFO:root:Thread: 1\treqs: 17\tmean time: 1.340s\t\n", + "INFO:root:Thread: 0\treqs: 23\tmean time: 0.820s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 9\tmean time: 1.457s\t\n", + "INFO:root:Thread: 2\treqs: 17\tmean time: 1.298s\t\n", + "INFO:root:Thread: 0\treqs: 32\tmean time: 0.459s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 18\tmean time: 1.312s\t\n", + "INFO:root:Thread: 2\treqs: 7\tmean time: 1.313s\t\n", + "INFO:root:Thread: 0\treqs: 34\tmean time: 0.389s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 18\tmean time: 1.204s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.278s\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.302s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.307s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 38\tmean time: 0.304s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.296s\tfast\t\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-16T18:43:08.232446Z", + "start_time": "2024-12-16T18:43:04.748446Z" + } + }, + "cell_type": "code", + "source": [ + "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.show()" + ], + "id": "113a8e2ddaa31689", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 2 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "### Skalowanie z odczekaniem - 5s", + "id": "5a9fdd8f3a7e16e1" + }, + { + "metadata": { + "ExecuteTime": { + "start_time": "2024-12-16T18:52:23.253459Z" + } + }, + "cell_type": "code", + "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", + "\n", + "API_URL=\"http://464979-LoadBalancer-0165784e7aab6ce5.elb.us-east-1.amazonaws.com:8080\"\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()" + ], + "id": "1dd74c36ea8583ba", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.308s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.319s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.326s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 0.753s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.457s\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.471s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.283s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.054s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.159s\t\n", + "INFO:root:Thread: 0\treqs: 3\tmean time: 0.636s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 2\tmean time: 1.484s\t\n", + "INFO:root:Thread: 2\treqs: 1\tmean time: 2.007s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 0.784s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.343s\t\n", + "INFO:root:Thread: 3\treqs: 2\tmean time: 1.404s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.357s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.212s\tfast\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.852s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.634s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 2.103s\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.416s\tfast\t\n", + "INFO:root:Thread: 4\treqs: 2\tmean time: 1.963s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.638s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 2.269s\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 3.795s\t\n", + "INFO:root:Thread: 4\treqs: 1\tmean time: 2.685s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 0.942s\tfast\t\n", + "INFO:root:Thread: 3\treqs: 1\tmean time: 1.513s\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.452s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.444s\t\n", + "INFO:root:Thread: 2\treqs: 2\tmean time: 1.434s\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.463s\tfast\t\n", + "INFO:root:Thread: 1\treqs: 2\tmean time: 1.531s\t\n", + "INFO:root:Thread: 1\treqs: 1\tmean time: 1.768s\t\n", + "INFO:root:Thread: 0\treqs: 2\tmean time: 1.028s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.299s\tfast\t\n", + "INFO:root:Thread: 0\treqs: 4\tmean time: 0.309s\tfast\t\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-12-16T19:05:15.538980Z", + "start_time": "2024-12-16T19:05:15.412945Z" + } + }, + "cell_type": "code", + "source": [ + "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.show()" + ], + "id": "fdf923e84b0ff64d", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}