modeling/AppMdl/AppMdl.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f4115668-6135-4563-a1d1-85779baea829",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import logging\n",
    "from io import BytesIO\n",
    "import time\n",
    "import zipfile\n",
    "import numpy as np\n",
    "import boto3\n",
    "from datetime import datetime, timezone\n",
    "from time import gmtime, strftime\n",
    "import json\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d84ad7ae-2a38-49c7-b864-011ef2477b4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "330a95bd-8e86-4b34-a5fc-7a29b7b711b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The difference between UTC and local timezone\n",
    "timezone_offset = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c814c135-967d-427d-aa38-e08505a9b178",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Function Name List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "60b3d6ea-473f-45eb-93e9-12ea3f0b5c6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AppMdl_f1', 'AppMdl_f2', 'AppMdl_f3', 'AppMdl_f4', 'AppMdl_f5', 'AppMdl_f6', 'AppMdl_f7', 'AppMdl_f8', 'AppMdl_f9', 'AppMdl_f10', 'AppMdl_f11', 'AppMdl_f12', 'AppMdl_f13', 'AppMdl_f14', 'AppMdl_f15', 'AppMdl_f16']\n"
     ]
    }
   ],
   "source": [
    "function_prefix = \"AppMdl\"\n",
    "function_count = 16\n",
    "function_name_list = [function_prefix+'_f'+str(i) for i in range(1, function_count+1)]\n",
    "print(function_name_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8a29f7de-1ef1-417a-9ea7-d51b1f4c8400",
   "metadata": {},
   "outputs": [],
   "source": [
    "mem_config_list={\n",
    "    'f1':1536,\n",
    "    'f2':1792,\n",
    "    'f3':576,\n",
    "    'f4':2240,\n",
    "    'f5':896,\n",
    "    'f6':1728,\n",
    "    'f7':128,\n",
    "    'f8':128,\n",
    "    'f9':256,\n",
    "    'f10':320,\n",
    "    'f11':1920,\n",
    "    'f12':1984,\n",
    "    'f13':1088,\n",
    "    'f14':640,\n",
    "    'f15':896,\n",
    "    'f16':1088\n",
    "}\n",
    "function_count = 16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd301cc9-b67e-4219-b7bc-89793c177c2d",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Execute the Application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "91a03034-9a62-4ce0-a948-7adea814d207",
   "metadata": {},
   "outputs": [],
   "source": [
    "sfn_client = boto3.client('stepfunctions')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6fa83e04-6072-4305-9002-b0338634d2f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "stateMachineArn='arn:aws:states:us-east-2:499537426559:stateMachine:AppMdl'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d96d440-386f-4583-a6f1-44133f95fde9",
   "metadata": {},
   "source": [
    "## Test Run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d8e75a7e-74b1-4c4d-8e9b-e92611d4af72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'executionArn': 'arn:aws:states:us-east-2:499537426559:express:AppMdl:a2394588-0f07-49d6-96ab-46e8eeaf1873:13e747b3-83ed-44d4-ad0b-5d6de53b7144',\n",
       " 'startDate': datetime.datetime(2021, 12, 26, 21, 45, 53, 78000, tzinfo=tzlocal()),\n",
       " 'ResponseMetadata': {'RequestId': '79103f11-2f24-4b98-91e6-59d4f500af84',\n",
       "  'HTTPStatusCode': 200,\n",
       "  'HTTPHeaders': {'x-amzn-requestid': '79103f11-2f24-4b98-91e6-59d4f500af84',\n",
       "   'content-type': 'application/x-amz-json-1.0',\n",
       "   'content-length': '174'},\n",
       "  'RetryAttempts': 0}}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfn_client.start_execution(\n",
    "    stateMachineArn=stateMachineArn,\n",
    "    input=\"{\\\"para1\\\":96, \\\"para2\\\":[1,2,3,4,100], \\\"para4\\\":64, \\\"para6\\\":[96,97,1,1,2,3,4,5,6]}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d18eea8-4791-426a-a6c2-bb61464c28e6",
   "metadata": {},
   "source": [
    "## Configure Logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "121b6fd6-39f9-4691-8607-f58c2b8a40f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "logging.basicConfig(filename='AppExecution.log', encoding='utf-8', format='%(asctime)s.%(msecs)03d %(message)s', datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca67a14f-ba2a-482a-9c51-4b4bdfdb9453",
   "metadata": {},
   "source": [
    "## Execute AppMdl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7f44bcd8-662a-4103-b7e9-69d9e79419f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(256)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "044dc9bc-98df-4d28-a4c7-460e30cf7b75",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5000):\n",
    "    payload_str=\"{\"+ \"\\\"para1\\\":{}, \\\"para2\\\":{}, \\\"para4\\\":{}, \\\"para6\\\":{}\".format(\n",
    "            np.random.randint(1, 101),\n",
    "            list(np.random.randint(1, 101, 20)), \n",
    "            np.random.randint(1, 101),\n",
    "            list(np.random.randint(1, 101, 20))\n",
    "    ) +\"}\"\n",
    "    response = sfn_client.start_execution(stateMachineArn=stateMachineArn, input=payload_str)\n",
    "    RequestId = response.get('ResponseMetadata', {}).get('RequestId')\n",
    "    StatusCode = response.get('ResponseMetadata', {}).get('HTTPStatusCode', 'ERR')\n",
    "    logging.info(f'{i+1} {StatusCode} {RequestId}')\n",
    "    time.sleep(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bea25bb-437e-4c4c-9f7c-ecca7fdac98b",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Get the start time and the end time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "3d2f0c12-c1ac-4de4-bb86-678856e2da5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "app_exeuction_start_time = ' '.join(os.popen('head -1 AppExecution.log').read().split(' ')[:2])\n",
    "app_execution_end_time = ' '.join(os.popen('tail -1 AppExecution.log').read().split(' ')[:2])\n",
    "app_exeuction_start_time = datetime.strptime(app_exeuction_start_time, '%Y-%m-%d %H:%M:%S.%f')\n",
    "app_execution_end_time = datetime.strptime(app_execution_end_time, '%Y-%m-%d %H:%M:%S.%f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "3a00a46e-7b52-47b6-89be-b10fbfdc5425",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2021, 12, 26, 21, 46, 17, 476000)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "app_exeuction_start_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "3ae3239d-f258-49ed-9079-391884507e30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2021, 12, 27, 11, 52, 6, 760000)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "app_execution_end_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "69063e3f-13ff-4773-82a0-22847511e16e",
   "metadata": {},
   "outputs": [],
   "source": [
    "app_exeuction_start_time = int(datetime.timestamp(app_exeuction_start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "9e20f1bb-bb60-4933-9809-40ef1e459d1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "app_execution_end_time = int(datetime.timestamp(app_execution_end_time)) + 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd7b9e07-bcc6-4f0d-a51b-51904fcec281",
   "metadata": {},
   "source": [
    "# Retrieve Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "27929e37-d03c-4b54-8ba5-8814c6e7cbe1",
   "metadata": {},
   "outputs": [],
   "source": [
    "logclient = boto3.client('logs')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81299d83-fa76-459a-aa01-934c2094b01e",
   "metadata": {},
   "source": [
    "## Query Step Functions Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "5cf150e4-afeb-47e3-b40f-8c92acb00e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_sfn_AppMdl = logclient.start_query(\n",
    "    logGroupName='/aws/vendedlogs/states/{}-Logs'.format('AppMdl'),\n",
    "    queryString=\"fields type, @timestamp| filter type = 'ExecutionStarted' or type = 'ExecutionSucceeded' | sort id desc\",\n",
    "    startTime=app_exeuction_start_time,\n",
    "    endTime=app_execution_end_time,\n",
    "    limit = 10000\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "622d48bf-9379-47f6-98e0-9a93ab869d6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_results_sfn_AppMdl = logclient.get_query_results(\n",
    "    queryId=query_sfn_AppMdl['queryId']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "fe67ae5e-e6c1-448f-b2c5-212d376347c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_starttimestamp = np.sort([datetime.timestamp(datetime.strptime(item[1]['value'], '%Y-%m-%d %H:%M:%S.%f'))+timezone_offset*3600 for item in query_results_sfn_AppMdl['results'] if item[0]['value']=='ExecutionStarted'])\n",
    "AppMdl_endtimestamp = np.sort([datetime.timestamp(datetime.strptime(item[1]['value'], '%Y-%m-%d %H:%M:%S.%f'))+timezone_offset*3600 for item in query_results_sfn_AppMdl['results'] if item[0]['value']=='ExecutionSucceeded'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "a072270d-8211-4296-aaff-1cc74de42f89",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame({'Start': AppMdl_starttimestamp, 'End':AppMdl_endtimestamp}).to_csv('AppMdl_SFN_Logs.csv', index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "72ea2eb3-8bea-43ac-9a4a-84672abecda2",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_sfn_logs = pd.read_csv('AppMdl_SFN_Logs.csv', low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7e90b083",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 2)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AppMdl_sfn_logs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef076385-0200-48d6-84b2-1e9d7100bfc4",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## Query Lambda Function Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "aa2c6981-3618-46d5-bcd3-f5986be7aa49",
   "metadata": {},
   "outputs": [],
   "source": [
    "timestamp_list = [' '.join(os.popen(f'head -1 AppExecution.log').read().split(' ')[:2])]\n",
    "for i in range(1000, 6000, 1000):\n",
    "    timestamp_list.append(' '.join(os.popen(f'head -{i} AppExecution.log | tail -1').read().split(' ')[:2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5c82c5-e44e-44bb-bf2d-f7ad30727f1e",
   "metadata": {},
   "source": [
    "### Functions for parsing Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2dbed2b7-a39a-4031-93a4-873ce516be8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def lambda_report_log_to_dict(log):\n",
    "    res={}\n",
    "    lis=[item.split(': ') for item in log[1]['value'].split('\\t')]\n",
    "    res['RequestId']=lis[0][1]\n",
    "    res['Duration']=float(lis[1][1].split(' ')[0])\n",
    "    res['Billed_Duration']=int(lis[2][1].split(' ')[0])\n",
    "    res['Memory_Size']=int(lis[3][1].split(' ')[0])\n",
    "    res['Max_Memory_Used']=int(lis[4][1].split(' ')[0])\n",
    "    res['UTC_Timestamp'] = time.mktime(datetime.strptime(log[0]['value'], \"%Y-%m-%d %H:%M:%S.%f\").timetuple()) +timezone_offset*3600\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "21f646d7-a4f9-47c0-b01a-f6529d49341b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2021-12-26 21:46:17.476',\n",
       " '2021-12-27 00:35:18.365',\n",
       " '2021-12-27 03:24:29.190',\n",
       " '2021-12-27 06:13:42.231',\n",
       " '2021-12-27 09:02:53.925',\n",
       " '2021-12-27 11:52:06.760']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timestamp_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f0364ae0-886a-498e-8bf4-f5da6c4282db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_time_string(s: str) -> int:\n",
    "    t = datetime.strptime(s, '%Y-%m-%d %H:%M:%S.%f')\n",
    "    t = datetime.timestamp(t)\n",
    "    return int(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0abfea9c-ef29-40f0-9756-c118027d09a5",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Prepare and Retrieve Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5fe7982e-d6ce-43e3-94d2-bf61e0a92380",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_lambda_logs_dict = {'f'+str(i):[] for i in range(1, function_count+1)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b47cea7-593c-461e-95c7-6642676e4f2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda = []\n",
    "for function in function_name_list:\n",
    "    query_lambda.append(logclient.start_query(\n",
    "        logGroupName='/aws/lambda/{}'.format(function),\n",
    "        queryString=\"fields @timestamp, @message| filter @message like 'REPORT'| sort @timestamp asc\",\n",
    "        startTime=process_time_string('2021-12-26 21:46:17.476') - 5,\n",
    "        endTime=process_time_string('2021-12-27 00:35:18.365') - 5,\n",
    "        limit=10000\n",
    "        ))\n",
    "    time.sleep(4)\n",
    "time.sleep(10)\n",
    "query_lambda_results = []\n",
    "for q in query_lambda:\n",
    "    query_lambda_results.append(logclient.get_query_results(\n",
    "        queryId=q['queryId']\n",
    "    ))\n",
    "    time.sleep(4)\n",
    "with open('query_lambda_results_part1.pickle', 'wb') as f:\n",
    "    f.write(pickle.dumps(query_lambda_results))\n",
    "for i in range(1, function_count+1):\n",
    "    AppMdl_lambda_logs_dict['f'+str(i)] = [lambda_report_log_to_dict(item) for item in query_lambda_results[i-1]['results']]\n",
    "    for item in AppMdl_lambda_logs_dict['f'+str(i)]:\n",
    "        item['Function']='f'+str(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "43611ce6-5f7a-4421-9233-24f3c8dc80a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(AppMdl_lambda_logs_dict['f1'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "de996842-fb92-45dd-b863-3596a2d89765",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda = []\n",
    "for function in function_name_list:\n",
    "    query_lambda.append(logclient.start_query(\n",
    "        logGroupName='/aws/lambda/{}'.format(function),\n",
    "        queryString=\"fields @timestamp, @message| filter @message like 'REPORT'| sort @timestamp asc\",\n",
    "        startTime=process_time_string('2021-12-27 00:35:18.365') - 5,\n",
    "        endTime=process_time_string('2021-12-27 03:24:29.190') - 5,\n",
    "        limit=10000\n",
    "        ))\n",
    "    time.sleep(4)\n",
    "query_lambda_results = []\n",
    "for q in query_lambda:\n",
    "    query_lambda_results.append(logclient.get_query_results(\n",
    "        queryId=q['queryId']\n",
    "    ))\n",
    "    time.sleep(4)\n",
    "with open('query_lambda_results_part2.pickle', 'wb') as f:\n",
    "    f.write(pickle.dumps(query_lambda_results))\n",
    "for i in range(1, function_count+1):\n",
    "    AppMdl_lambda_logs_dict['f'+str(i)] += [lambda_report_log_to_dict(item) for item in query_lambda_results[i-1]['results']]\n",
    "    for item in AppMdl_lambda_logs_dict['f'+str(i)]:\n",
    "        item['Function']='f'+str(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6f489404-db65-4dcd-a6c8-eecdba24d77b",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda = []\n",
    "for function in function_name_list:\n",
    "    query_lambda.append(logclient.start_query(\n",
    "        logGroupName='/aws/lambda/{}'.format(function),\n",
    "        queryString=\"fields @timestamp, @message| filter @message like 'REPORT'| sort @timestamp asc\",\n",
    "        startTime=process_time_string('2021-12-27 03:24:29.190') - 5,\n",
    "        endTime=process_time_string('2021-12-27 06:13:42.231') - 5,\n",
    "        limit=10000\n",
    "        ))\n",
    "    time.sleep(4)\n",
    "query_lambda_results = []\n",
    "for q in query_lambda:\n",
    "    query_lambda_results.append(logclient.get_query_results(\n",
    "        queryId=q['queryId']\n",
    "    ))\n",
    "    time.sleep(4)\n",
    "with open('query_lambda_results_part3.pickle', 'wb') as f:\n",
    "    f.write(pickle.dumps(query_lambda_results))\n",
    "for i in range(1, function_count+1):\n",
    "    AppMdl_lambda_logs_dict['f'+str(i)] += [lambda_report_log_to_dict(item) for item in query_lambda_results[i-1]['results']]\n",
    "    for item in AppMdl_lambda_logs_dict['f'+str(i)]:\n",
    "        item['Function']='f'+str(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "38ffa2b4-fa97-4916-9e60-5df712e02aba",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda = []\n",
    "for function in function_name_list:\n",
    "    query_lambda.append(logclient.start_query(\n",
    "        logGroupName='/aws/lambda/{}'.format(function),\n",
    "        queryString=\"fields @timestamp, @message| filter @message like 'REPORT'| sort @timestamp asc\",\n",
    "        startTime=process_time_string('2021-12-27 06:13:42.231') - 5,\n",
    "        endTime=process_time_string('2021-12-27 09:02:53.925') - 5,\n",
    "        limit=10000\n",
    "        ))\n",
    "    time.sleep(4)\n",
    "query_lambda_results = []\n",
    "for q in query_lambda:\n",
    "    query_lambda_results.append(logclient.get_query_results(\n",
    "        queryId=q['queryId']\n",
    "    ))\n",
    "    time.sleep(4)\n",
    "with open('query_lambda_results_part4.pickle', 'wb') as f:\n",
    "    f.write(pickle.dumps(query_lambda_results))\n",
    "for i in range(1, function_count+1):\n",
    "    AppMdl_lambda_logs_dict['f'+str(i)] += [lambda_report_log_to_dict(item) for item in query_lambda_results[i-1]['results']]\n",
    "    for item in AppMdl_lambda_logs_dict['f'+str(i)]:\n",
    "        item['Function']='f'+str(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "34ebf8e8-cc51-44f0-b980-f057bf6f9135",
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda = []\n",
    "for function in function_name_list:\n",
    "    query_lambda.append(logclient.start_query(\n",
    "        logGroupName='/aws/lambda/{}'.format(function),\n",
    "        queryString=\"fields @timestamp, @message| filter @message like 'REPORT'| sort @timestamp asc\",\n",
    "        startTime=process_time_string('2021-12-27 09:02:53.925') - 5,\n",
    "        endTime=process_time_string('2021-12-27 11:52:06.760') + 5,\n",
    "        limit=10000\n",
    "        ))\n",
    "    time.sleep(4)\n",
    "query_lambda_results = []\n",
    "for q in query_lambda:\n",
    "    query_lambda_results.append(logclient.get_query_results(\n",
    "        queryId=q['queryId']\n",
    "    ))\n",
    "    time.sleep(4)\n",
    "with open('query_lambda_results_part5.pickle', 'wb') as f:\n",
    "    f.write(pickle.dumps(query_lambda_results))\n",
    "for i in range(1, function_count+1):\n",
    "    AppMdl_lambda_logs_dict['f'+str(i)] += [lambda_report_log_to_dict(item) for item in query_lambda_results[i-1]['results']]\n",
    "    for item in AppMdl_lambda_logs_dict['f'+str(i)]:\n",
    "        item['Function']='f'+str(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "21a6add5-b366-4bb4-a5c8-4a2bdc69b978",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('AppMdl_lambda_logs_dict.pickle', 'wb') as f:\n",
    "    f.write(pickle.dumps(AppMdl_lambda_logs_dict))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56ad6510-0766-4518-b61c-7c21ff8b1d16",
   "metadata": {},
   "source": [
    "#### Convert Logs into DataFrame and Save as CSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d69579e2-aa51-4db6-8c56-8da15d83b592",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_lambda_logs=pd.DataFrame()\n",
    "for i in range(1, function_count+1):\n",
    "    AppMdl_lambda_logs = AppMdl_lambda_logs.append(pd.DataFrame(AppMdl_lambda_logs_dict['f'+str(i)]))\n",
    "AppMdl_lambda_logs.index=range(AppMdl_lambda_logs.shape[0])\n",
    "AppMdl_lambda_logs=AppMdl_lambda_logs[['Function', 'Memory_Size', 'Max_Memory_Used', 'Duration', 'Billed_Duration', 'UTC_Timestamp', 'RequestId']]\n",
    "AppMdl_lambda_logs.to_csv('AppMdl_lambda_logs.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "e3971dd7-fd7d-4200-9aeb-4976418a2088",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_lambda_logs = pd.read_csv('AppMdl_lambda_logs.csv', low_memory=False)\n",
    "AppMdl_lambda_logs.columns = ['Function', 'Memory_Size', 'Max_Memory_Used', 'Duration', 'Billed_Duration', 'UTCTimestamp', 'RequestId']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0e6ad292-5ccf-47a3-ad1d-321ed03f1dbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Function</th>\n",
       "      <th>Memory_Size</th>\n",
       "      <th>Max_Memory_Used</th>\n",
       "      <th>Duration</th>\n",
       "      <th>Billed_Duration</th>\n",
       "      <th>UTCTimestamp</th>\n",
       "      <th>RequestId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>617.06</td>\n",
       "      <td>618</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>6d6a9102-db93-4699-a7af-514cfbef0265</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>712.13</td>\n",
       "      <td>713</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>03d04889-047d-4167-aa17-305875b4abc4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>600.10</td>\n",
       "      <td>601</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>a2fa4433-9689-403e-984f-73701bedab12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>737.77</td>\n",
       "      <td>738</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>a58f8cb7-7f6e-4238-a4de-8913e8be059d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>39</td>\n",
       "      <td>603.87</td>\n",
       "      <td>604</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>8dc0af8c-9944-49cd-ae3d-8b3d28cfb42d</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Function  Memory_Size  Max_Memory_Used  Duration  Billed_Duration  \\\n",
       "0       f1         1536               38    617.06              618   \n",
       "1       f1         1536               38    712.13              713   \n",
       "2       f1         1536               38    600.10              601   \n",
       "3       f1         1536               38    737.77              738   \n",
       "4       f1         1536               39    603.87              604   \n",
       "\n",
       "   UTCTimestamp                             RequestId  \n",
       "0  1.640555e+09  6d6a9102-db93-4699-a7af-514cfbef0265  \n",
       "1  1.640555e+09  03d04889-047d-4167-aa17-305875b4abc4  \n",
       "2  1.640555e+09  a2fa4433-9689-403e-984f-73701bedab12  \n",
       "3  1.640555e+09  a58f8cb7-7f6e-4238-a4de-8913e8be059d  \n",
       "4  1.640555e+09  8dc0af8c-9944-49cd-ae3d-8b3d28cfb42d  "
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AppMdl_lambda_logs.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f03c8ad6-ccf2-472f-a69d-d1dd5f8151e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f1 5000 691.541994\n",
      "f2 5000 205.230394\n",
      "f3 5588 526.5487276306371\n",
      "f4 3017 842.1539211136891\n",
      "f5 1983 208.11401916288452\n",
      "f6 5588 518.4042358625626\n",
      "f7 5000 322.995504\n",
      "f8 49990 212.44284736947384\n",
      "f9 4466 147.43433049708912\n",
      "f10 1122 363.4150445632799\n",
      "f11 1983 900.0714876449823\n",
      "f12 1983 784.3699646999496\n",
      "f13 1983 381.93210287443264\n",
      "f14 49990 232.4744122824565\n",
      "f15 4674 273.6729888746257\n",
      "f16 4466 184.72936632333187\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, function_count+1):\n",
    "    print(f\"f{i}\", AppMdl_lambda_logs.query(f\"Function == 'f{i}'\").shape[0], AppMdl_lambda_logs.query(f\"Function == 'f{i}'\")['Duration'].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "2b000450-7a0e-49c0-aaf5-b88a7bc16814",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_cost(rt: float, mem: float, pmms: float = 0.0000166667/1024/1000, ppi: float = 0.0000002) -> float:\n",
    "    return math.ceil(rt) * mem * pmms + ppi\n",
    "\n",
    "def adjacent_values(vals, q1, q3):\n",
    "    upper_adjacent_value = q3 + (q3 - q1) * 1.5\n",
    "    upper_adjacent_value = np.clip(upper_adjacent_value, q3, vals[-1])\n",
    "\n",
    "    lower_adjacent_value = q1 - (q3 - q1) * 1.5\n",
    "    lower_adjacent_value = np.clip(lower_adjacent_value, vals[0], q1)\n",
    "    return lower_adjacent_value, upper_adjacent_value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09931042-8c68-4d1a-8cf1-13415a9696cd",
   "metadata": {},
   "source": [
    "# End-to-end RT Reported by AWS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "b2d697a7-6a3f-4e58-8766-b77244f013b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_duration = pd.DataFrame((AppMdl_sfn_logs['End'] - AppMdl_sfn_logs['Start'])*1000, columns=['Duration'])\n",
    "AppMdl_duration.to_csv('AppMdl_duration_aws.csv', index=False)\n",
    "AppMdl_duration = pd.read_csv('AppMdl_duration_aws.csv', low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "6607571f-1c1d-470b-bd64-eed59bea9a9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Executions:  5000\n",
      "Average Duration Reported by AWS:  3482.393802547455 ms\n",
      "Median Duration Reported by AWS:  3309.000015258789 ms\n",
      "10-th percentile of Duration Reported by AWS:  3099.9999046325684 ms\n",
      "90-th percentile Duration Reported by AWS:  4466.100072860718 ms\n",
      "Standard Deviation of Duration Reported by AWS:  634.7561576851803 ms\n"
     ]
    }
   ],
   "source": [
    "print('Number of Executions: ', len(AppMdl_duration['Duration']))\n",
    "AppMdl_avg_duration_aws = np.mean(AppMdl_duration['Duration'])\n",
    "AppMdl_mid_duration_aws = np.median(AppMdl_duration['Duration'])\n",
    "AppMdl_percentile10_aws = np.percentile(AppMdl_duration['Duration'], 10)\n",
    "AppMdl_percentile90_aws = np.percentile(AppMdl_duration['Duration'], 90)\n",
    "print('Average Duration Reported by AWS: ', AppMdl_avg_duration_aws, 'ms')\n",
    "print('Median Duration Reported by AWS: ', AppMdl_mid_duration_aws, 'ms')\n",
    "print('10-th percentile of Duration Reported by AWS: ', AppMdl_percentile10_aws, 'ms')\n",
    "print('90-th percentile Duration Reported by AWS: ', AppMdl_percentile90_aws, 'ms')\n",
    "print('Standard Deviation of Duration Reported by AWS: ', np.std(AppMdl_duration['Duration']), 'ms')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee2aa0f1-b0ad-4a09-b96b-4b5b750de825",
   "metadata": {},
   "source": [
    "# Cost Reported by AWS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "3dc92773-3bb9-4707-b9e0-cdb22b6a1fd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Start</th>\n",
       "      <th>End</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>1.640555e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>1.640555e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>1.640555e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>1.640555e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>1.640555e+09</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Start           End\n",
       "0  1.640555e+09  1.640555e+09\n",
       "1  1.640555e+09  1.640555e+09\n",
       "2  1.640555e+09  1.640555e+09\n",
       "3  1.640555e+09  1.640555e+09\n",
       "4  1.640555e+09  1.640555e+09"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AppMdl_sfn_logs.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "db855aaf-2f93-4948-842a-0864aa3e7fd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Function</th>\n",
       "      <th>Memory_Size</th>\n",
       "      <th>Max_Memory_Used</th>\n",
       "      <th>Duration</th>\n",
       "      <th>Billed_Duration</th>\n",
       "      <th>UTCTimestamp</th>\n",
       "      <th>RequestId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>617.06</td>\n",
       "      <td>618</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>6d6a9102-db93-4699-a7af-514cfbef0265</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>712.13</td>\n",
       "      <td>713</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>03d04889-047d-4167-aa17-305875b4abc4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>600.10</td>\n",
       "      <td>601</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>a2fa4433-9689-403e-984f-73701bedab12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>38</td>\n",
       "      <td>737.77</td>\n",
       "      <td>738</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>a58f8cb7-7f6e-4238-a4de-8913e8be059d</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>39</td>\n",
       "      <td>603.87</td>\n",
       "      <td>604</td>\n",
       "      <td>1.640555e+09</td>\n",
       "      <td>8dc0af8c-9944-49cd-ae3d-8b3d28cfb42d</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Function  Memory_Size  Max_Memory_Used  Duration  Billed_Duration  \\\n",
       "0       f1         1536               38    617.06              618   \n",
       "1       f1         1536               38    712.13              713   \n",
       "2       f1         1536               38    600.10              601   \n",
       "3       f1         1536               38    737.77              738   \n",
       "4       f1         1536               39    603.87              604   \n",
       "\n",
       "   UTCTimestamp                             RequestId  \n",
       "0  1.640555e+09  6d6a9102-db93-4699-a7af-514cfbef0265  \n",
       "1  1.640555e+09  03d04889-047d-4167-aa17-305875b4abc4  \n",
       "2  1.640555e+09  a2fa4433-9689-403e-984f-73701bedab12  \n",
       "3  1.640555e+09  a58f8cb7-7f6e-4238-a4de-8913e8be059d  \n",
       "4  1.640555e+09  8dc0af8c-9944-49cd-ae3d-8b3d28cfb42d  "
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AppMdl_lambda_logs.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "64fe3aa8-c700-4267-ba0e-8a6123ae57f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "cost_list = []\n",
    "for index, row in AppMdl_sfn_logs.iterrows():\n",
    "    cost = 0\n",
    "    app_start = row['Start'] - 2\n",
    "    app_end = row['End'] + 2\n",
    "    lambda_logs = AppMdl_lambda_logs.query(f\"\"\"UTCTimestamp>{app_start} and UTCTimestamp<{app_end}\"\"\")\n",
    "    for i, r in lambda_logs.iterrows():\n",
    "        memory_size = r['Memory_Size']\n",
    "        duration = r['Duration']\n",
    "        cost += calculate_cost(rt=duration, mem=memory_size) * 1000000\n",
    "    cost_list.append(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "8f415400-3518-4f47-b479-0a9e0cadb7d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Cost Reported by AWS:  131.88937225460123 USD\n",
      "Median Cost Reported by AWS:  120.56533369687502 USD\n",
      "10-th percentile of Cost Reported by AWS:  111.80614959187497 USD\n",
      "90-th percentile Cost Reported by AWS:  152.83300119874997 USD\n",
      "Standard Deviation of Cost Reported by AWS:  20.16068515599438 USD\n"
     ]
    }
   ],
   "source": [
    "AppMdl_avg_cost_aws = np.mean(cost_list)\n",
    "AppMdl_mid_cost_aws = np.median(cost_list)\n",
    "AppMdl_percentile10_cost_aws = np.percentile(cost_list, 10)\n",
    "AppMdl_percentile90_cost_aws = np.percentile(cost_list, 90)\n",
    "AppMdl_std_cost_aws = np.std(cost_list)\n",
    "print('Average Cost Reported by AWS: ', AppMdl_avg_cost_aws, 'USD')\n",
    "print('Median Cost Reported by AWS: ', AppMdl_mid_cost_aws, 'USD')\n",
    "print('10-th percentile of Cost Reported by AWS: ', AppMdl_percentile10_cost_aws, 'USD')\n",
    "print('90-th percentile Cost Reported by AWS: ', AppMdl_percentile90_cost_aws, 'USD')\n",
    "print('Standard Deviation of Cost Reported by AWS: ', AppMdl_std_cost_aws, 'USD')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "405bc00d-2ada-4cfe-8d7e-5dc9d9e3dd23",
   "metadata": {},
   "source": [
    "# End-to-end RT and Cost Derived from the Modeling Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "54ae84b4-a6ec-45d9-8941-4b97e9884c30",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../../')\n",
    "from slappsim.Structures import *\n",
    "from slappsim.Function import *\n",
    "from slappsim.PetriApp import *\n",
    "from slappsim.States import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "c6b6523d-6e33-4568-9b95-ceff7e6a1f69",
   "metadata": {},
   "outputs": [],
   "source": [
    "performance_profile = pd.read_csv('AppMdl_lambda_logs_performance_profile.csv', low_memory=False)\n",
    "performance_profile.columns = ['Function', 'Memory_Size', 'Max_Memory_Used', 'Duration', 'Billed_Duration',\n",
    "                              'UTCTimestamp', 'RequestId']\n",
    "scheduling_overhead = pd.read_csv('../sfn-delay/Scheduling_Overhead.csv')\n",
    "scheduling_overhead = np.array(scheduling_overhead['scheduling_overhead'].to_list())\n",
    "function_execution_delay = pd.read_csv('../sfn-delay/Function_Execution_Delay.csv')\n",
    "function_execution_delay = np.array(function_execution_delay['Duration'].to_list())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "788f7f2a-6d9d-4053-8c3d-c6eff1acfb02",
   "metadata": {},
   "outputs": [],
   "source": [
    "rs = np.random.RandomState(64)\n",
    "random.seed(64)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85d50e7f-65cd-464c-a780-c8dd73f854b5",
   "metadata": {},
   "source": [
    "## Define the application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "61ad81ff-bc29-4f8c-81c8-b10c6c01528b",
   "metadata": {},
   "outputs": [],
   "source": [
    "f1_rt = np.array(performance_profile.query(f\"Function=='f1'\")['Duration'].to_list()[500:9501])\n",
    "f1_pp_fun = partial(rs.choice, a=f1_rt)\n",
    "f1 = Function(pf_fun=f1_pp_fun, mem=mem_config_list['f1'], name='f1')\n",
    "f2_rt = np.array(performance_profile.query(f\"Function=='f2'\")['Duration'].to_list()[500:9501])\n",
    "f2_pp_fun = partial(rs.choice, a=f2_rt)\n",
    "f2 = Function(pf_fun=f2_pp_fun, mem=mem_config_list['f2'], name='f2')\n",
    "f3_rt = np.array(performance_profile.query(f\"Function=='f3'\")['Duration'].to_list()[500:9501])\n",
    "f3_pp_fun = partial(rs.choice, a=f3_rt)\n",
    "f3 = Function(pf_fun=f3_pp_fun, mem=mem_config_list['f3'], name='f3')\n",
    "f4_rt = np.array(performance_profile.query(f\"Function=='f4'\")['Duration'].to_list()[500:9501])\n",
    "f4_pp_fun = partial(rs.choice, a=f4_rt)\n",
    "f4 = Function(pf_fun=f4_pp_fun, mem=mem_config_list['f4'], name='f4')\n",
    "f5_rt = np.array(performance_profile.query(f\"Function=='f5'\")['Duration'].to_list()[500:9501])\n",
    "f5_pp_fun = partial(rs.choice, a=f5_rt)\n",
    "f5 = Function(pf_fun=f5_pp_fun, mem=mem_config_list['f5'], name='f5')\n",
    "f6_rt = np.array(performance_profile.query(f\"Function=='f6'\")['Duration'].to_list()[500:9501])\n",
    "f6_pp_fun = partial(rs.choice, a=f6_rt)\n",
    "f6 = Function(pf_fun=f6_pp_fun, mem=mem_config_list['f6'], name='f6')\n",
    "f7_rt = np.array(performance_profile.query(f\"Function=='f7'\")['Duration'].to_list()[500:9501])\n",
    "f7_pp_fun = partial(rs.choice, a=f7_rt)\n",
    "f7 = Function(pf_fun=f7_pp_fun, mem=mem_config_list['f7'], name='f7')\n",
    "f8_rt = np.array(performance_profile.query(f\"Function=='f8'\")['Duration'].to_list()[500:9501])\n",
    "f8_pp_fun = partial(rs.choice, a=f8_rt)\n",
    "f8 = Function(pf_fun=f8_pp_fun, mem=mem_config_list['f8'], name='f8')\n",
    "f9_rt = np.array(performance_profile.query(f\"Function=='f9'\")['Duration'].to_list()[500:9501])\n",
    "f9_pp_fun = partial(rs.choice, a=f9_rt)\n",
    "f9 = Function(pf_fun=f9_pp_fun, mem=mem_config_list['f9'], name='f9')\n",
    "f10_rt = np.array(performance_profile.query(f\"Function=='f10'\")['Duration'].to_list()[500:9501])\n",
    "f10_pp_fun = partial(rs.choice, a=f10_rt)\n",
    "f10 = Function(pf_fun=f10_pp_fun, mem=mem_config_list['f10'], name='f10')\n",
    "f11_rt = np.array(performance_profile.query(f\"Function=='f11'\")['Duration'].to_list()[500:9501])\n",
    "f11_pp_fun = partial(rs.choice, a=f11_rt)\n",
    "f11 = Function(pf_fun=f11_pp_fun, mem=mem_config_list['f11'], name='f11')\n",
    "f12_rt = np.array(performance_profile.query(f\"Function=='f12'\")['Duration'].to_list()[500:9501])\n",
    "f12_pp_fun = partial(rs.choice, a=f12_rt)\n",
    "f12 = Function(pf_fun=f12_pp_fun, mem=mem_config_list['f12'], name='f12')\n",
    "f13_rt = np.array(performance_profile.query(f\"Function=='f13'\")['Duration'].to_list()[500:9501])\n",
    "f13_pp_fun = partial(rs.choice, a=f13_rt)\n",
    "f13 = Function(pf_fun=f13_pp_fun, mem=mem_config_list['f13'], name='f13')\n",
    "f14_rt = np.array(performance_profile.query(f\"Function=='f14'\")['Duration'].to_list()[500:9501])\n",
    "f14_pp_fun = partial(rs.choice, a=f14_rt)\n",
    "f14 = Function(pf_fun=f14_pp_fun, mem=mem_config_list['f14'], name='f14')\n",
    "f15_rt = np.array(performance_profile.query(f\"Function=='f15'\")['Duration'].to_list()[500:9501])\n",
    "f15_pp_fun = partial(rs.choice, a=f15_rt)\n",
    "f15 = Function(pf_fun=f15_pp_fun, mem=mem_config_list['f15'], name='f15')\n",
    "f16_rt = np.array(performance_profile.query(f\"Function=='f16'\")['Duration'].to_list()[500:9501])\n",
    "f16_pp_fun = partial(rs.choice, a=f16_rt)\n",
    "f16 = Function(pf_fun=f16_pp_fun, mem=mem_config_list['f16'], name='f16')\n",
    "sfn_scheduling_overhead_fun = partial(rs.choice, a=scheduling_overhead)\n",
    "function_execution_delay_fun = partial(rs.choice, a=function_execution_delay)\n",
    "delays = {'FunctionExecution': function_execution_delay_fun, 'SchedulingOverhead': sfn_scheduling_overhead_fun}\n",
    "start = Start()\n",
    "end = End()\n",
    "pass1 = Pass()\n",
    "pass2 = Pass()\n",
    "sequence1_parallel2 = Sequence(actions=[f11])\n",
    "sequence2_parallel2 = Sequence(actions=[f12, f13])\n",
    "parallel2 = Parallel(branches=[sequence1_parallel2, sequence2_parallel2])\n",
    "sequence1_choice1 = Sequence(actions=[f4])\n",
    "sequence2_choice1 = Sequence(actions=[f5, parallel2])\n",
    "choice1 = Choice(choices=[sequence1_choice1, sequence2_choice1], probabilities=[0.6, 0.4])\n",
    "sequence1_parallel1 = Sequence(actions=[f2, choice1, pass1])\n",
    "choice6 = Choice(choices=[f16, f15], probabilities=[0.95, 0.05], end=False)\n",
    "sequence1_choice4 = Sequence(actions=[f9, f15, choice6, f16])\n",
    "sequence2_choice4 = Sequence(actions=[f10])\n",
    "choice4 = Choice(choices=[sequence1_choice4, sequence2_choice4], probabilities=[0.8, 0.2])\n",
    "choice2 = Choice(choices=[pass2, f3], probabilities=[0.9, 0.1], end=False)\n",
    "sequence2_parallel1 = Sequence(actions=[f3, choice4, f6, choice2, pass2])\n",
    "parallel1 = Parallel(branches=[sequence1_parallel1, sequence2_parallel1])\n",
    "sequence_map1 = Sequence(actions=[f8, f14])\n",
    "map1 = Map(sequence=sequence_map1, iterations=10)\n",
    "sequence1 = Sequence(actions=[f1, parallel1, f7, map1])\n",
    "structures = [pass1, pass2, sequence1_parallel2, sequence2_parallel2, parallel2, sequence1_choice1, sequence2_choice1,\n",
    "              choice1, sequence1_parallel1, choice6, sequence1_choice4, sequence2_choice4, choice4, choice2,\n",
    "              sequence2_parallel1, parallel1, sequence_map1, map1, sequence1]\n",
    "i1 = InArc(place=start)\n",
    "o1 = OutArc(place=sequence1.structure_start)\n",
    "t1 = Transition(in_arcs=[i1], out_arcs=[o1])\n",
    "i2 = InArc(place=sequence1.structure_end)\n",
    "o2 = OutArc(place=end)\n",
    "t2 = Transition(in_arcs=[i2], out_arcs=[o2])\n",
    "transitions = [t1, t2]\n",
    "transitions += sequence1.transitions\n",
    "appmdl = PetriApp(transitions=transitions,\n",
    "                  functions=[f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16],\n",
    "                  structures=structures,\n",
    "                  delays=delays)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3cca967-6dec-4845-bf35-7d6b5c290afb",
   "metadata": {},
   "source": [
    "## Run the modeling algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "c5b179cc-126e-4db2-976b-563515cfd749",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Duration Reported by Algorithm:  3481.3801966017204 ms\n",
      "Median Duration Reported by Algorithm:  3313.209970436096 ms\n",
      "10-th percentile of Duration Reported by Algorithm:  3089.8916997833244 ms\n",
      "90-th percentile Duration Reported by Algorithm:  4466.090224876404 ms\n",
      "Standard Deviation of Duration Reported by Algorithm:  623.250203312969 ms\n",
      "Average Cost Reported by Algorithm:  133.26451374483406 USD\n",
      "Median Cost Reported by Algorithm:  122.66846330312501 USD\n",
      "10-th percentile of Cost Reported by Algorithm:  112.2168795 USD\n",
      "90-th percentile Cost Reported by Algorithm:  155.7523820375 USD\n",
      "Standard Deviation of Cost Reported by Algorithm:  20.597538614983776 USD\n"
     ]
    }
   ],
   "source": [
    "ert = []\n",
    "ec = []\n",
    "for i in range(100000):\n",
    "    rt, c, s, logs = appmdl.execute()\n",
    "    ert.append(rt)\n",
    "    ec.append(c * 1000000)\n",
    "    appmdl.reset()\n",
    "appmdl_avg_cost_mdl = np.mean(ec)\n",
    "appmdl_mid_cost_mdl = np.median(ec)\n",
    "appmdl_percentile10_cost_mdl = np.percentile(ec, 10)\n",
    "appmdl_percentile90_cost_mdl = np.percentile(ec, 90)\n",
    "appmdl_std_cost_mdl = np.std(ec)\n",
    "appmdl_avg_ert_mdl = np.mean(ert)\n",
    "appmdl_mid_ert_mdl = np.median(ert)\n",
    "appmdl_percentile10_ert_mdl = np.percentile(ert, 10)\n",
    "appmdl_percentile90_ert_mdl = np.percentile(ert, 90)\n",
    "appmdl_std_ert_mdl = np.std(ert)\n",
    "print('Average Duration Reported by Algorithm: ', appmdl_avg_ert_mdl, 'ms')\n",
    "print('Median Duration Reported by Algorithm: ', appmdl_mid_ert_mdl, 'ms')\n",
    "print('10-th percentile of Duration Reported by Algorithm: ', appmdl_percentile10_ert_mdl, 'ms')\n",
    "print('90-th percentile Duration Reported by Algorithm: ', appmdl_percentile90_ert_mdl, 'ms')\n",
    "print('Standard Deviation of Duration Reported by Algorithm: ', appmdl_std_ert_mdl, 'ms')\n",
    "print('Average Cost Reported by Algorithm: ', appmdl_avg_cost_mdl, 'USD')\n",
    "print('Median Cost Reported by Algorithm: ', appmdl_mid_cost_mdl, 'USD')\n",
    "print('10-th percentile of Cost Reported by Algorithm: ', appmdl_percentile10_cost_mdl, 'USD')\n",
    "print('90-th percentile Cost Reported by Algorithm: ', appmdl_percentile90_cost_mdl, 'USD')\n",
    "print('Standard Deviation of Cost Reported by Algorithm: ', appmdl_std_cost_mdl, 'USD')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "0563d36d-f32b-4d44-a1a8-ef4927376e32",
   "metadata": {},
   "outputs": [],
   "source": [
    "AppMdl_cost_aws = pd.DataFrame(pd.Series(cost_list), columns=['Cost'])\n",
    "AppMdl_cost_aws.to_csv('AppMdl_cost_aws.csv', index=False)\n",
    "AppMdl_duration_model = pd.DataFrame(pd.Series(ert), columns=['Duration'])\n",
    "AppMdl_duration_model.to_csv('AppMdl_duration_model.csv', index=False)\n",
    "AppMdl_cost_model = pd.DataFrame(pd.Series(ec), columns=['Cost'])\n",
    "AppMdl_cost_model.to_csv('AppMdl_cost_model.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e5af549-dc4a-45e5-a30d-97b08e249063",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9",
   "language": "python",
   "name": "python3.9"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}