run.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c36df411",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import json\n",
    "from collections import defaultdict\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from scipy import stats\n",
    "\n",
    "file_name = \"../raw_data/azurefunctions-dataset2019/invocations_per_function_md.anon.d\"\n",
    "train_file_names, test_file_names = [file_name+\"%02d.csv\" % (i) for i in range(1, 13)], [file_name+\"13.csv\", file_name+\"14.csv\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9ce08b94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(71616, 39388)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_func_arrcount = {}\n",
    "train_func_owner_app = {}\n",
    "train_owner_func = defaultdict(set)\n",
    "train_app_func = defaultdict(set)\n",
    "\n",
    "func_trigger = defaultdict(set)\n",
    "\n",
    "for i, file in enumerate(train_file_names):\n",
    "    df = pd.read_csv(file)\n",
    "    \n",
    "    for _, row in df.iterrows():\n",
    "        func = row[\"HashFunction\"]\n",
    "        train_func_owner_app[func] = row[\"HashOwner\"]+'\\t'+row[\"HashApp\"]\n",
    "        train_owner_func[row[\"HashOwner\"]].add(func)\n",
    "        train_app_func[row[\"HashApp\"]].add(func)\n",
    "        func_trigger[func].add(row[\"Trigger\"])\n",
    "        \n",
    "        if func not in train_func_arrcount:\n",
    "            train_func_arrcount[func] = [0]*12*1440\n",
    "        train_func_arrcount[func][i*1440: (i+1)*1440] = list(row[4:].values)\n",
    "    del df\n",
    "\n",
    "test_func_arrcount = {}\n",
    "test_func_owner_app = {}\n",
    "test_owner_func = defaultdict(set)\n",
    "test_app_func = defaultdict(set)\n",
    "\n",
    "for i, file in enumerate(test_file_names):\n",
    "    df = pd.read_csv(file)\n",
    "    \n",
    "    for _, row in df.iterrows():\n",
    "        func = row[\"HashFunction\"]\n",
    "        test_func_owner_app[func] = row[\"HashOwner\"]+'\\t'+row[\"HashApp\"]\n",
    "        test_owner_func[row[\"HashOwner\"]].add(func)\n",
    "        test_app_func[row[\"HashApp\"]].add(func)\n",
    "        func_trigger[func].add(row[\"Trigger\"])\n",
    "        \n",
    "        if func not in test_func_arrcount:\n",
    "            test_func_arrcount[func] = [0]*2*1440    \n",
    "        test_func_arrcount[func][i*1440: (i+1)*1440] = list(row[4:].values)\n",
    "    del df\n",
    "    \n",
    "train_NUM, test_NUM = len(train_func_arrcount), len(test_func_arrcount)\n",
    "train_NUM, test_NUM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "40ca3162",
   "metadata": {},
   "outputs": [],
   "source": [
    "class func_state:\n",
    "    def __init__(self, _type = 0, forget = 0):\n",
    "        self.type = _type\n",
    "        self.forget = forget\n",
    "        \n",
    "        self.state = False # loaded or not\n",
    "        self.load_time = None \n",
    "        self.wait_time = None \n",
    "        self.last_call = None\n",
    "        self.pre_call_start = None # start of the last calling series\n",
    "        \n",
    "        self.idle_info = {} \n",
    "        self.invok_info = {}\n",
    "        \n",
    "        self.pred_value = []\n",
    "        self.next_invok_start = []\n",
    "        \n",
    "        self.adp_wait = []\n",
    "    \n",
    "    def load(self, load_time):\n",
    "        self.state = True\n",
    "        self.load_time = load_time\n",
    "    \n",
    "    def cal_lasting(self, cur_time):\n",
    "        if not self.state:\n",
    "            return 0\n",
    "        return cur_time - load_time + 1\n",
    "    \n",
    "    def unload(self):\n",
    "        self.state = False\n",
    "        self.load_time = None\n",
    "    \n",
    "    def cal_wait(self):\n",
    "        if self.wait_time is None:\n",
    "            self.wait_time = 0\n",
    "        self.wait_time += 1\n",
    "    \n",
    "    def reset(self, pred=False):\n",
    "        self.unload()\n",
    "        self.wait_time = None \n",
    "        self.last_call = None\n",
    "        self.pre_call_start = None\n",
    "        \n",
    "        self.adp_wait = []\n",
    "        \n",
    "        if pred:\n",
    "            self.next_invok_start = []\n",
    "\n",
    "func_class = {}\n",
    "for func in train_func_arrcount:\n",
    "    func_class[func] = func_state()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ba4d874f",
   "metadata": {},
   "outputs": [],
   "source": [
    "FILL_ZERO_FLAG = True\n",
    "shown_func_num = 1000\n",
    "UNKNOWN, WARM, REGULAR, APPRO_REGULAR, DENSE, SUCCESSIVE, PLUSED, POSSIBLE, CORR, NEW_POSS = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 #Diviable? Active?\n",
    "TYPE_NUM = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3fc5d19",
   "metadata": {},
   "source": [
    "# Well-known Function Categorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e941399e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def conj_seq_lst(lst, count_invok=False, threshold=1):\n",
    "    seq_lenth_lst = []\n",
    "    pre_pos = -1\n",
    "    for i, e in enumerate(lst):\n",
    "        if not (bool(e) ^ count_invok):\n",
    "            if pre_pos < 0:\n",
    "                pre_pos = i\n",
    "            if i == len(lst)-1 and i+1-pre_pos >= threshold:\n",
    "                seq_lenth_lst.append(i+1-pre_pos)\n",
    "        else:\n",
    "            if pre_pos>=0 and i-pre_pos >= threshold:\n",
    "                seq_lenth_lst.append(i-pre_pos)\n",
    "            pre_pos = -1\n",
    "    return seq_lenth_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2b19d92d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge(lst):\n",
    "    unique, counts = np.unique(lst, return_counts=True)\n",
    "    mode = unique[np.argmax(counts)]\n",
    "    if mode < 500: return lst\n",
    "    if max(counts) < len(counts) / 2: return lst\n",
    "    \n",
    "    used = [False] * len(lst)\n",
    "    new_lst = []\n",
    "\n",
    "    for i in range(0, len(lst)):\n",
    "        if lst[i] <= mode*0.25:\n",
    "            continue\n",
    "        else:\n",
    "            cur = lst[i]\n",
    "            for k in range(1, i+1):\n",
    "                cur_idx = max(0, i-k)\n",
    "                if lst[cur_idx] >= mode * 0.75: break\n",
    "                if cur + lst[cur_idx] <= mode and lst[cur_idx] <= mode*0.25 and not used[cur_idx]:\n",
    "                    used[cur_idx] = True\n",
    "                    cur += lst[cur_idx]\n",
    "            for k in range(1, len(lst)-i):\n",
    "                cur_idx = min(len(lst)-1, i+k)\n",
    "                if lst[cur_idx] >= mode * 0.75: break\n",
    "                if cur + lst[cur_idx] <= mode and lst[cur_idx] <= mode*0.25 and not used[cur_idx]:\n",
    "                    used[cur_idx] = True\n",
    "                    cur += lst[cur_idx]\n",
    "        new_lst.append(cur)\n",
    "    \n",
    "    if sum(used) / len(used) > 0.3:\n",
    "        return lst\n",
    "    \n",
    "    return new_lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c917137",
   "metadata": {},
   "source": [
    "### Always warm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "04d8666d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [01:27<00:00, 815.97it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1119, 720)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "always_num = 0\n",
    "almost_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if 0 not in arrcount:\n",
    "            func_class[func].type = WARM\n",
    "            always_num += 1\n",
    "        \n",
    "        elif np.count_nonzero(np.array(arrcount) == 0) < 0.001 * len(arrcount):\n",
    "            func_class[func].type = WARM\n",
    "            almost_num += 1\n",
    "        \n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "\n",
    "warm_num = almost_num + always_num\n",
    "almost_num, always_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ced72c3",
   "metadata": {},
   "source": [
    "### Regular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c4b3952a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [07:05<00:03, 167.03it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(16193, 14809, 1384, 350)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SEQ_NUM_BOUND = 3 #Too infrequently invoked functions should not be categorized to this type.\n",
    "\n",
    "regu1_num, regu2_num = 0, 0 \n",
    "merge_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "            \n",
    "        if func_class[func].type >= REGULAR: \n",
    "            func_class[func].type = 0\n",
    "        \n",
    "        if func_class[func].type != 0: continue\n",
    "            \n",
    "        non_invok = conj_seq_lst(arrcount)\n",
    "        invok = conj_seq_lst(arrcount, count_invok=True)\n",
    "        \n",
    "        if len(invok) >= SEQ_NUM_BOUND and len(non_invok) > 0:\n",
    "            unique, counts = np.unique(non_invok, return_counts=True)\n",
    "            mode = unique[np.argmax(counts)]\n",
    "        \n",
    "            if mode - non_invok[0] > 2:\n",
    "                if arrcount[-1] > 0:\n",
    "                    non_invok = non_invok[1:]\n",
    "                else:\n",
    "                    non_invok = non_invok[1:-1]\n",
    "            \n",
    "            if len(non_invok) > SEQ_NUM_BOUND:\n",
    "                if np.percentile(non_invok, 95) - np.percentile(non_invok, 5) < 1:\n",
    "                    func_class[func].type = REGULAR\n",
    "                    regu1_num += 1\n",
    "                elif np.std(non_invok) / np.mean(non_invok) <= 0.01:\n",
    "                    func_class[func].type = REGULAR\n",
    "                    regu2_num += 1\n",
    "                \n",
    "            ##slacking\n",
    "            if FILL_ZERO_FLAG and func_class[func].type == 0:\n",
    "                non_invok = merge(non_invok)\n",
    "                \n",
    "                if np.percentile(non_invok, 95) - np.percentile(non_invok, 5) < 1:\n",
    "                    func_class[func].type = REGULAR\n",
    "                    regu1_num += 1\n",
    "                elif np.std(non_invok) / np.mean(non_invok) <= 0.01:\n",
    "                    func_class[func].type = REGULAR\n",
    "                    regu2_num += 1\n",
    "                \n",
    "                merge_num += (func_class[func].type == REGULAR)\n",
    "\n",
    "        \n",
    "regular_num = regu1_num + regu2_num\n",
    "regular_num, regu1_num, regu2_num, merge_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f031bd53",
   "metadata": {},
   "source": [
    "### Appro Regular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dfbccbf6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [02:54<00:01, 406.57it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6242"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IDLE_NUM_MAX = 3 #Consider the first n modes\n",
    "IDLE_PERCEN = 0.9\n",
    "\n",
    "appro_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "\n",
    "        if func_class[func].type >= APPRO_REGULAR:\n",
    "            func_class[func].type = 0\n",
    "        \n",
    "        if func_class[func].type == 0:\n",
    "                \n",
    "            non_invok = conj_seq_lst(arrcount)\n",
    "            if len(non_invok) < SEQ_NUM_BOUND: continue\n",
    "            \n",
    "            non_invok_unique, non_invok_counts = np.unique(non_invok, return_counts=True)\n",
    "            non_mode_max_index = np.argsort(-non_invok_counts)[:IDLE_NUM_MAX]\n",
    "            \n",
    "            if max(non_invok_counts) > 1:#If all WT values only appear once, it's meaningless.\n",
    "                if sum(non_invok_counts[non_mode_max_index]) >= sum(non_invok_counts) * IDLE_PERCEN:\n",
    "                    appro_num += 1\n",
    "                    func_class[func].type = APPRO_REGULAR\n",
    "                    \n",
    "appro_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d68a66fb",
   "metadata": {},
   "source": [
    "### Dense"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c463fa80",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [02:36<00:01, 452.51it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "405"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DENSE_UPPER_BOUND = 5 #the small constant\n",
    "DENSE_PERCEN = 90\n",
    "\n",
    "dense_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if func_class[func].type >= DENSE:\n",
    "            func_class[func].type = 0\n",
    "        \n",
    "        if func_class[func].type == 0:\n",
    "            non_invok = conj_seq_lst(arrcount)\n",
    "            if np.percentile(non_invok, DENSE_PERCEN) < DENSE_UPPER_BOUND:\n",
    "                dense_num += 1\n",
    "                func_class[func].type = DENSE\n",
    "        \n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "\n",
    "dense_num  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d14bd6e5",
   "metadata": {},
   "source": [
    "### Successive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "08c8daf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_AN_seq(lst):\n",
    "    seq_lenth_num = []\n",
    "    pre_pos = -1\n",
    "    for i, e in enumerate(lst):\n",
    "        if bool(e):\n",
    "            if pre_pos < 0:\n",
    "                pre_pos = i\n",
    "            if i == len(lst)-1 and i-pre_pos >= 0:\n",
    "                seq_lenth_num.append(sum(lst[pre_pos:i+1]))\n",
    "        else:\n",
    "            if pre_pos >= 0 and i-pre_pos >= 1:\n",
    "                seq_lenth_num.append(sum(lst[pre_pos:i]))\n",
    "            pre_pos = -1\n",
    "    return seq_lenth_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d8433b90",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [03:11<00:01, 371.52it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1683"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gamma_1 = 10\n",
    "gamma_2 = 11\n",
    "\n",
    "successive_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if func_class[func].type >= SUCCESSIVE:\n",
    "            func_class[func].type = 0\n",
    "            \n",
    "        if func_class[func].type == 0:\n",
    "            invok = conj_seq_lst(arrcount, count_invok=True)\n",
    "            invok_seq_num = cal_AN_seq(arrcount)\n",
    "            \n",
    "            if min(invok) >= gamma_1 or min(invok_seq_num) >= gamma_2:\n",
    "                successive_num += 1\n",
    "                func_class[func].type = SUCCESSIVE\n",
    "        \n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "\n",
    "successive_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9bc3964",
   "metadata": {},
   "source": [
    "## Forgetting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "fb461aaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def re_categorzing(arrcount):\n",
    "    #Always warm:\n",
    "    if min(arrcount) > 0: \n",
    "        return WARM, 0\n",
    "    if np.count_nonzero(np.array(arrcount) == 0) < 0.001 * len(arrcount):\n",
    "        return WARM, 0\n",
    "    \n",
    "    invok = conj_seq_lst(arrcount, count_invok=True)\n",
    "    non_invok = conj_seq_lst(arrcount)\n",
    "    \n",
    "    if len(invok) >= SEQ_NUM_BOUND:\n",
    "        non_invok_reg = [i for i in non_invok]\n",
    "        if arrcount[-1] == 0: #no so-called first WT\n",
    "            non_invok_reg = non_invok_reg[:-1]\n",
    "            \n",
    "        if np.percentile(non_invok_reg, 95) - np.percentile(non_invok_reg, 5) < 1:\n",
    "            return REGULAR, 1\n",
    "        if np.std(non_invok_reg) / np.mean(non_invok_reg) <= 0.01:\n",
    "            return REGULAR, 2\n",
    "        \n",
    "        if FILL_ZERO_FLAG:\n",
    "            non_invok_reg = merge(non_invok_reg)\n",
    "            if np.percentile(non_invok_reg, 95) - np.percentile(non_invok_reg, 5) < 1:\n",
    "                return REGULAR, 1\n",
    "            if np.std(non_invok_reg) / np.mean(non_invok_reg) <= 0.01:\n",
    "                return REGULAR, 2\n",
    "    \n",
    "        non_invok_unique, non_invok_counts = np.unique(non_invok, return_counts=True)\n",
    "        non_mode_max_index = np.argsort(-non_invok_counts)[:IDLE_NUM_MAX]\n",
    "\n",
    "        #Appro Regular     \n",
    "        if max(non_invok_counts) > 1 and \\\n",
    "            sum(non_invok_counts[non_mode_max_index]) >= sum(non_invok_counts) * IDLE_PERCEN:\n",
    "            return APPRO_REGULAR, 0\n",
    "    \n",
    "    if np.percentile(non_invok, DENSE_PERCEN) < DENSE_UPPER_BOUND:\n",
    "        return DENSE, 0\n",
    "    \n",
    "    if min(invok) >= gamma_1 or min(cal_AN_seq(arrcount)) > gamma_2:\n",
    "        return SUCCESSIVE, 0\n",
    "    \n",
    "    return UNKNOWN, 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "5a0239a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "^^^^^ Forgetting day 1 ^^^^^\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [01:14<00:00, 953.15it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "169\n",
      "^^^^^ Forgetting day 2 ^^^^^\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|██████████████████████████████████▋| 71000/71616 [00:58<00:00, 1206.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "171\n",
      "^^^^^ Forgetting day 3 ^^^^^\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|██████████████████████████████████▋| 71000/71616 [00:45<00:00, 1559.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "218\n",
      "^^^^^ Forgetting day 4 ^^^^^\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|██████████████████████████████████▋| 71000/71616 [00:32<00:00, 2204.50it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "230\n",
      "^^^^^ Forgetting day 5 ^^^^^\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|██████████████████████████████████▋| 71000/71616 [00:21<00:00, 3276.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "269\n",
      "^^^^^ Forgetting day 6 ^^^^^\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|██████████████████████████████████▋| 71000/71616 [00:15<00:00, 4438.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Regular num: 92 80\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1060, '***', [44194, 1857, 16365, 6722, 459, 2019])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DAY = 6\n",
    "change_num_day = [0] * DAY\n",
    "change_num = 0\n",
    "\n",
    "regular_type_num = [0, 0, 0]\n",
    "num_per_type = [0, warm_num, regular_num, appro_num, dense_num, successive_num, 0, 0, 0, 0]\n",
    "\n",
    "for day in range(1, DAY + 1):\n",
    "    print(\"^\"*5, \"Forgetting day\", day, \"^\"*5)\n",
    "    c = 0\n",
    "    with tqdm(total=train_NUM) as pbar:\n",
    "        for func in train_func_arrcount:\n",
    "            c += 1\n",
    "            if c % shown_func_num == 0:\n",
    "                pbar.update(shown_func_num)\n",
    "                \n",
    "            if func_class[func].forget >= day:\n",
    "                func_class[func].forget = 0\n",
    "                func_class[func].type = 0\n",
    "            \n",
    "            if func_class[func].type == 0:\n",
    "                arrcount = train_func_arrcount[func][1440*day: ]\n",
    "\n",
    "                if sum(arrcount) > 0:\n",
    "                    func_class[func].type, regular_type = re_categorzing(arrcount)\n",
    "                    regular_type_num[regular_type] += 1\n",
    "\n",
    "                    if func_class[func].type > 0:\n",
    "                        change_num += 1\n",
    "                        change_num_day[day - 1] += 1\n",
    "                        func_class[func].forget = day\n",
    "                        num_per_type[func_class[func].type] += 1\n",
    "    \n",
    "    print(change_num_day[day-1])\n",
    "\n",
    "print(\"Regular num:\", regular_type_num[1], regular_type_num[2])\n",
    "num_per_type[0] = len(train_func_arrcount) - sum(num_per_type) #Unknown\n",
    "change_num, \"***\", num_per_type[: SUCCESSIVE+1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09f589a2",
   "metadata": {},
   "source": [
    "## Show & Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "38d14484",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|████████████████████████████████▋| 71000/71616 [00:00<00:00, 824448.05it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "44194"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pie_count = [0] * 6\n",
    "before_forget_pie_count = [0] * 6\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if func_class[func].type >= PLUSED:\n",
    "            func_class[func].type = 0\n",
    "            \n",
    "        pie_count[func_class[func].type] += 1\n",
    "        \n",
    "        if func_class[func].forget > 0:\n",
    "            before_forget_pie_count[0] += 1\n",
    "        else:\n",
    "            before_forget_pie_count[func_class[func].type] += 1\n",
    "        \n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "\n",
    "pie_count[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "1a3a887f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "label_lst = ['Unknown','Warm', 'Regular', \"Appro-regular\", \"Dense\", \"Successive\"]\n",
    "color_lst = ['#F5B3A2','#BC90B6','#2A4597','#DDC3C7', '#6A9C79', '#C5563B',\"#F1AB3D\", '#58A0A4','#E5F1E5',\"#FBDEAF\"]\n",
    "\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 4))\n",
    "plt.subplots_adjust(wspace=1, hspace =0)\n",
    "\n",
    "ax1.pie(np.array(before_forget_pie_count),\n",
    "        labels = label_lst,\n",
    "        colors = color_lst[:6],\n",
    "        #explode = [0, 0.2, 0, 0, 0.7, 0, 0.1],\n",
    "        autopct='%.1f%%',\n",
    "        pctdistance=0.9,\n",
    "       )\n",
    "ax1.set_title('Before forgetting')\n",
    "\n",
    "ax2.pie(np.array(pie_count),\n",
    "        labels = label_lst,\n",
    "        colors = color_lst[:6],\n",
    "        #explode = [0, 0.2, 0, 0, 0.7, 0, 0.1],\n",
    "        autopct='%.1f%%',\n",
    "        pctdistance=0.9,\n",
    "       )\n",
    "ax2.set_title('After forgetting')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "8a57e5c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Save categorization\n",
    "import os\n",
    "os.makedirs(\"mid-data\", exist_ok=True)\n",
    "with open(\"mid-data/train_info.txt\", \"w\") as wf:\n",
    "    for func, state in func_class.items():\n",
    "        wf.write(func+'\\t'+str(state.type)+'\\t'+str(state.forget)+'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "2f8b53c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Save for calculating correlations\n",
    "\n",
    "with open(\"mid-data/cal_corr/to_cal_corr.txt\", \"w\") as wf:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        wf.write(func+'\\t'+str(func_class[func].forget)+'\\t'+','.join(str(a) for a in arrcount)+'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4a817b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "to_cal_corr_num = 0\n",
    "with open(\"mid-data/cal_corr/unknown_ownerapp_lst.txt\", \"w\") as wf:\n",
    "    for func, state in func_class.items():\n",
    "        if state.type == 0:\n",
    "            [owner, app] = train_func_owner_app[func].split('\\t')\n",
    "            ownerapp_lst = (train_owner_func[owner] | train_app_func[app])\n",
    "            ownerapp_lst.remove(func)\n",
    "            if len(ownerapp_lst) > 0:\n",
    "                to_cal_corr_num += 1\n",
    "                wf.write(func+'\\t'+','.join(list(ownerapp_lst))+'\\n')\n",
    "to_cal_corr_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8752f7a",
   "metadata": {},
   "source": [
    "## Indeterminte Function Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "2eea3016",
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_split_DAY = 9\n",
    "func_valid_res = {func: {\"cold\": [20000]*3, \"waste\": [20000]*3} \n",
    "                  for func in train_func_arrcount \n",
    "                  if func_class[func].type >= PLUSED or func_class[func].type == 0\n",
    "                 }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "179b1254",
   "metadata": {},
   "source": [
    "### Plused"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "e35965c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|██████████████████████████████████▋| 71000/71616 [00:52<00:00, 1362.74it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(13277, 30917)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PLUSED_GIVEUP = 3\n",
    "useless_num = 0\n",
    "takein_assign_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arr in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "        \n",
    "        if func_class[func].type >= PLUSED:\n",
    "            func_class[func].type = 0\n",
    "        if func_class[func].type != 0: continue\n",
    "    \n",
    "        valid_arr = arr[1440*valid_split_DAY: ]\n",
    "        waste, used = 0, np.count_nonzero(valid_arr)\n",
    "        cold_num, invok_num = 0, sum(valid_arr)\n",
    "        \n",
    "        if invok_num <= 0: \n",
    "            useless_num += 1\n",
    "            continue\n",
    "        \n",
    "        takein_assign_num += 1\n",
    "        \n",
    "        state = False\n",
    "        for i, cur_invok in enumerate(valid_arr):\n",
    "            if cur_invok > 0:\n",
    "                if not state:\n",
    "                    state = True\n",
    "                    cold_num += 1\n",
    "            elif state:\n",
    "                waste += 1\n",
    "                if sum(valid_arr[max(0, i+1-PLUSED_GIVEUP): i]) == 0:\n",
    "                    state = False\n",
    "            \n",
    "            func_valid_res[func][\"cold\"][0], func_valid_res[func][\"waste\"][0] = cold_num/invok_num, waste/used\n",
    "\n",
    "useless_num, takein_assign_num  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e1e9f02",
   "metadata": {},
   "source": [
    "### Possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "72338233",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [03:53<00:02, 303.95it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "22148"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PRE_WARM = 2\n",
    "POSS_GIVEUP = 1\n",
    "DISCRETE_TH = 10\n",
    "\n",
    "takein_poss_num = 0\n",
    "possible = set()\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arr in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "        \n",
    "        if func_class[func].type >= POSSIBLE:\n",
    "            func_class[func].type = 0\n",
    "            \n",
    "        if func_class[func].type != 0: continue\n",
    "        train_arr, valid_arr = arr[:1440 * valid_split_DAY], arr[1440 * valid_split_DAY:]\n",
    "        \n",
    "        waste, used = 0, np.count_nonzero(valid_arr)\n",
    "        cold_num, invok_num = 0, sum(valid_arr)\n",
    "        \n",
    "        non_invok = conj_seq_lst(arr)\n",
    "        non_invok_unique, non_invok_counts = np.unique(non_invok, return_counts=True)\n",
    "        \n",
    "        if invok_num == 0: \n",
    "            if max(non_invok_counts) >= 2:\n",
    "                possible.add(func)\n",
    "            continue\n",
    "        if max(non_invok_counts) < 2: continue\n",
    "        \n",
    "        takein_poss_num += 1\n",
    "        state = False\n",
    "        ############## Calculate ##############\n",
    "        cut = min(5, sum(np.where(non_invok_counts > 1, 1, 0)))\n",
    "        non_mode_max_index = np.argsort(-non_invok_counts)[:cut]\n",
    "        modes = non_invok_unique[non_mode_max_index]\n",
    "        \n",
    "        if max(modes) - min(modes) <= DISCRETE_TH:\n",
    "            pred_value = [min(modes), max(modes)]\n",
    "            pred_value_discrete = False\n",
    "        else:\n",
    "            pred_value = sorted(list(modes))\n",
    "            pred_value_discrete = True\n",
    "        \n",
    "        ############## Calculate ##############\n",
    "        \n",
    "        \n",
    "        next_invok_start = []\n",
    "        wait_time = 1440 * valid_split_DAY\n",
    "        \n",
    "        ############## Prewarming at time 0 ##############\n",
    "        if np.count_nonzero(train_arr) > 0:\n",
    "            last_call = np.where(np.array(train_arr) > 0)[0][-1] - len(train_arr)\n",
    "            wait_time = non_invok[-1] if train_arr[-1] == 0 else 0\n",
    "            if pred_value_discrete:\n",
    "                next_invok_start = [(last_call + p + 1, last_call + p + 1) for p in pred_value]\n",
    "            else:\n",
    "                next_invok_start = [(last_call + pred_value[0] + 1, last_call + pred_value[1] + 1)]\n",
    "        \n",
    "            if train_arr[-1] > 0: state = True\n",
    "\n",
    "        for (left, right) in next_invok_start:\n",
    "            if left <= PRE_WARM and right >= -PRE_WARM:\n",
    "                state = True\n",
    "                break\n",
    "        ############## Prewarming at time 0 ##############\n",
    "        \n",
    "        \n",
    "        for i, cur_invok in enumerate(valid_arr):\n",
    "            if cur_invok > 0:\n",
    "                if not state:\n",
    "                    state = True\n",
    "                    cold_num += 1\n",
    "                \n",
    "                last_call = i\n",
    "                wait_time = 0\n",
    "                if pred_value_discrete:\n",
    "                    next_invok_start = [(i + p + 1, i + p + 1) for p in pred_value]\n",
    "                else:\n",
    "                    next_invok_start = [(i + pred_value[0] + 1, i + pred_value[1] + 1)]\n",
    "            else:\n",
    "                wait_time += 1\n",
    "                pre_warm_flag = False\n",
    "                for (left, right) in next_invok_start:\n",
    "                    if left <= i + PRE_WARM and right >= i - PRE_WARM:\n",
    "                        pre_warm_flag = True\n",
    "                        break      \n",
    "                if state:\n",
    "                    waste += 1\n",
    "                    if (not pre_warm_flag) and wait_time >= POSS_GIVEUP:\n",
    "                        state = False\n",
    "                elif pre_warm_flag:\n",
    "                    state = True\n",
    "        \n",
    "        func_valid_res[func][\"cold\"][1], func_valid_res[func][\"waste\"][1] = cold_num/invok_num, waste/used\n",
    "\n",
    "takein_poss_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ff9e305",
   "metadata": {},
   "source": [
    "### Correlated\n",
    "\n",
    "#### Load Connections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "17b3d489",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27123"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os \n",
    "import json\n",
    "def read_json(filepath):\n",
    "    if os.path.exists(filepath):\n",
    "        assert filepath.endswith('.json')\n",
    "        with open(filepath, 'r') as f:\n",
    "            return json.loads(f.read())\n",
    "    else: \n",
    "        print(\"File path \"+filepath+\" not exists!\")\n",
    "        return\n",
    "\n",
    "train_candi = read_json(\"mid-data/func_candi.json\")\n",
    "    \n",
    "len(train_candi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df56f95a",
   "metadata": {},
   "source": [
    "#### Calculate the predictive values of candidate functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "629caa85",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████▊| 27000/27123 [07:04<00:01, 63.64it/s]\n"
     ]
    }
   ],
   "source": [
    "candi_pred_value = defaultdict(list)\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=len(train_candi)) as pbar:\n",
    "    for _, tri_tuple_lst in train_candi.items():\n",
    "        c += 1\n",
    "        if c % (shown_func_num) == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "        \n",
    "        for (candi_func, _, _) in tri_tuple_lst:\n",
    "            if candi_func in candi_pred_value: continue\n",
    "            \n",
    "            arrcount = train_func_arrcount[candi_func][1440*func_class[candi_func].forget:]\n",
    "            non_invok = conj_seq_lst(arrcount)\n",
    "\n",
    "            if func_class[candi_func].type == REGULAR: \n",
    "                candi_pred_value[candi_func] = [np.median(non_invok)]\n",
    "\n",
    "            elif func_class[candi_func].type in [APPRO_REGULAR, DENSE]:\n",
    "                non_invok_unique, non_invok_counts = np.unique(non_invok, return_counts=True)\n",
    "                non_mode_max_index = np.argsort(-non_invok_counts)[: min(5, sum(np.where(non_invok_counts > 1, 1, 0)))]\n",
    "                \n",
    "                if func_class[candi_func].type == APPRO_REGULAR:\n",
    "                    candi_pred_value[candi_func] = non_invok_unique[non_mode_max_index[: min(len(non_mode_max_index), IDLE_NUM_MAX)]].tolist()\n",
    "\n",
    "                elif func_class[candi_func].type == DENSE:\n",
    "                    if len(non_mode_max_index) > 0:\n",
    "                        candi_pred_value[candi_func] = [min(non_invok_unique[non_mode_max_index]), \n",
    "                                                        min(DENSE_UPPER_BOUND, max(non_invok_unique[non_mode_max_index]))]\n",
    "                    else:\n",
    "                        candi_pred_value[candi_func] = [min(non_invok_unique), min(DENSE_UPPER_BOUND, max(non_invok_unique))]       \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e695f288",
   "metadata": {},
   "source": [
    "#### Calculate the last call of candidate functions at each time i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "14343629",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████▊| 27000/27123 [00:46<00:00, 582.08it/s]\n"
     ]
    }
   ],
   "source": [
    "candi_last_call_dict = {}\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=len(train_candi)) as pbar:\n",
    "    for _, tri_tuple_lst in train_candi.items():\n",
    "        c += 1\n",
    "        if c % (shown_func_num) == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "        \n",
    "        for (candi_func, _, _) in tri_tuple_lst:\n",
    "            if candi_func in candi_last_call_dict: continue\n",
    "            \n",
    "            candi_func_arrcount = train_func_arrcount[candi_func][: 1440 * valid_split_DAY]\n",
    "            if max(candi_func_arrcount) > 0:\n",
    "                last_call = np.where(np.array(candi_func_arrcount) > 0)[0][-1] - len(candi_func_arrcount)\n",
    "            else:\n",
    "                last_call = None\n",
    "            \n",
    "            valid_arr = train_func_arrcount[candi_func][1440 * valid_split_DAY: ]\n",
    "            candi_last_call_dict[candi_func] = [None] * len(valid_arr)\n",
    "            \n",
    "            for i, cur_invok in enumerate(valid_arr):\n",
    "                if cur_invok > 0:\n",
    "                    last_call = i\n",
    "                    candi_last_call_dict[candi_func][i] = i\n",
    "                else:\n",
    "                    candi_last_call_dict[candi_func][i] = last_call"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d325419",
   "metadata": {},
   "source": [
    "#### Run correlated validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "6ea8123a",
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████▉| 27100.0/27123 [04:10<00:00, 108.28it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7077"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CORR_GIVEUP = 1\n",
    "\n",
    "takein_corr_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=len(train_candi)) as pbar:\n",
    "    for func, tri_tuple_lst in train_candi.items():\n",
    "        c += 1\n",
    "        if c % (shown_func_num/10) == 0:\n",
    "            pbar.update(shown_func_num/10)\n",
    "        \n",
    "        if func_class[func].type >= CORR:\n",
    "            func_class[func].type = 0\n",
    "            \n",
    "        if func_class[func].type != 0: continue\n",
    "        \n",
    "        train_arr, valid_arr = train_func_arrcount[func][:1440*valid_split_DAY], train_func_arrcount[func][1440*valid_split_DAY:]\n",
    "        waste, used = 0, np.count_nonzero(valid_arr)\n",
    "        cold_num, invok_num = 0, sum(valid_arr)\n",
    "        if invok_num <= 0: continue\n",
    "        \n",
    "        takein_corr_num += 1\n",
    "        \n",
    "        next_invok_start = []\n",
    "        ############## Calculate next_invok_start at time 0 ##############\n",
    "        for (candi_func, lag, _) in tri_tuple_lst:\n",
    "           \n",
    "            candi_func_arrcount = train_func_arrcount[candi_func][: 1440 * valid_split_DAY]\n",
    "            \n",
    "            if np.count_nonzero(candi_func_arrcount) > 0:\n",
    "                candi_last_call = np.where(np.array(candi_func_arrcount) > 0)[0][-1] - len(candi_func_arrcount)\n",
    "                next_invok_start += [(candi_last_call, candi_last_call + lag)]\n",
    "\n",
    "                if func_class[candi_func].type in [REGULAR, APPRO_REGULAR]:\n",
    "                    next_invok_start += [(candi_last_call + 1 + p, candi_last_call + 1 + p + lag) \n",
    "                                           for p in candi_pred_value[candi_func]]\n",
    "                elif func_class[candi_func].type == DENSE:\n",
    "                    next_invok_start += [(candi_last_call + 1 + candi_pred_value[candi_func][0], \n",
    "                                            candi_last_call + 1 + candi_pred_value[candi_func][1] + lag)]\n",
    "        \n",
    "        ############## Calculate next_invok_start at time 0 ##############\n",
    "        \n",
    "        state = False\n",
    "        wait_time = 1440 * valid_split_DAY\n",
    "        \n",
    "        ############## Prewarming at time 0 ##############\n",
    "        if np.count_nonzero(train_arr) > 0:\n",
    "            last_call = np.where(np.array(train_arr) > 0)[0][-1] - len(train_arr)\n",
    "            wait_time = non_invok[-1] if train_arr[-1] == 0 else 0\n",
    "            if train_arr[-1] > 0: state = True\n",
    "        \n",
    "        for (left, right) in next_invok_start:\n",
    "            if left <= PRE_WARM and right >= -PRE_WARM:\n",
    "                state = True\n",
    "                break\n",
    "        ############## Prewarming at time 0 ##############\n",
    "        \n",
    "        for i, cur_invok in enumerate(valid_arr):\n",
    "            next_invok_start = []\n",
    "            for (candi_func, lag, _) in tri_tuple_lst:\n",
    "                if candi_last_call_dict[candi_func][i] is not None:\n",
    "                    candi_last_call = candi_last_call_dict[candi_func][i]\n",
    "                    next_invok_start += [(candi_last_call, candi_last_call + lag)]\n",
    "\n",
    "                    if func_class[candi_func].type in [REGULAR, APPRO_REGULAR]:\n",
    "                        next_invok_start += [(candi_last_call + 1 + p, candi_last_call + 1 + p + lag) \n",
    "                                               for p in candi_pred_value[candi_func]]\n",
    "\n",
    "                    elif func_class[candi_func].type == DENSE:\n",
    "                        next_invok_start += [(candi_last_call + 1 + candi_pred_value[candi_func][0], \n",
    "                                            candi_last_call + 1 + candi_pred_value[candi_func][1] + lag)]\n",
    "\n",
    "            if cur_invok > 0:\n",
    "                if not state:\n",
    "                    state = True\n",
    "                    cold_num += 1\n",
    "                wait_time = 0\n",
    "            \n",
    "            else:\n",
    "                wait_time += 1\n",
    "                pre_warm_flag = False\n",
    "                for (left, right) in next_invok_start:\n",
    "                    if left <= i + PRE_WARM and right >= i - PRE_WARM:\n",
    "                        pre_warm_flag = True\n",
    "                        break\n",
    "\n",
    "                if state:\n",
    "                    waste += 1\n",
    "                    if (not pre_warm_flag) and wait_time >= CORR_GIVEUP:\n",
    "                        state = False\n",
    "                elif pre_warm_flag:\n",
    "                    state = True\n",
    "                \n",
    "        func_valid_res[func][\"cold\"][2], func_valid_res[func][\"waste\"][2] = cold_num/invok_num, waste/used\n",
    "\n",
    "takein_corr_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "701adfec",
   "metadata": {},
   "source": [
    "### Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "969fb23b",
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33971 of the 10223, 44194 unknown functions are assigned.\n",
      "10223/13277 functions don't fit any of the three rules.\n",
      "30917 22148 7077 functions are tried to fit for the three rules.\n",
      "5159 functions are assigned smoothly.\n",
      "3862 functions are assigned with a bad grace.\n",
      "10422 functions are assigned forcibly: 844 are plused, 7809 are possible, and 1769 are CORR.\n"
     ]
    }
   ],
   "source": [
    "alpha = 0.5\n",
    "\n",
    "final_res = {}\n",
    "good_assign_num, unknown_valid_num, bad_assign_num = 0, 0, 0\n",
    "force_assign = [0] * 3\n",
    "\n",
    "\n",
    "for func, res in func_valid_res.items():\n",
    "    if min(res[\"cold\"]) < 20000:\n",
    "        \n",
    "        cold_idx, waste_idx = np.argmin(res[\"cold\"]), np.argmin(res[\"waste\"])\n",
    "\n",
    "        if cold_idx == waste_idx and res[\"cold\"][cold_idx] < 1:\n",
    "            final_res[func] = cold_idx\n",
    "            good_assign_num += 1\n",
    "\n",
    "        else:\n",
    "            if cold_idx < waste_idx and res[\"cold\"][cold_idx] == res[\"cold\"][waste_idx]: #same cold, choose the smaller waste\n",
    "                final_res[func] = waste_idx\n",
    "                good_assign_num += 1\n",
    "            elif waste_idx < cold_idx and res[\"waste\"][cold_idx] == res[\"waste\"][waste_idx]:\n",
    "                final_res[func] = cold_idx\n",
    "                good_assign_num += 1\n",
    "\n",
    "            elif res[\"cold\"][cold_idx] <= 0.1: #avoid zero division\n",
    "                final_res[func] = cold_idx\n",
    "\n",
    "            elif res[\"cold\"][cold_idx] == 1:\n",
    "                bad_assign_num += 1\n",
    "                if func in possible:\n",
    "                    final_res[func] = 1\n",
    "                else:\n",
    "                    final_res[func] = 0\n",
    "\n",
    "            else:\n",
    "                if func in possible:\n",
    "                    final_res[func] = 1\n",
    "                else:\n",
    "                    delta_cold = alpha * (res[\"cold\"][waste_idx] - res[\"cold\"][cold_idx])/res[\"cold\"][cold_idx]\n",
    "                    delta_waste = (res[\"waste\"][cold_idx] - res[\"waste\"][waste_idx])/res[\"waste\"][waste_idx]\n",
    "                    if delta_cold <= delta_waste:\n",
    "                        final_res[func] = cold_idx\n",
    "                    else:\n",
    "                        final_res[func] = waste_idx   \n",
    "\n",
    "                force_assign[final_res[func]] += 1\n",
    "    else:\n",
    "        if func in possible:\n",
    "            final_res[func] = 1\n",
    "        else:\n",
    "            unknown_valid_num += 1\n",
    "        continue\n",
    "\n",
    "for func, idx in final_res.items():\n",
    "    func_class[func].type = PLUSED+idx\n",
    "\n",
    "print(f\"{len(final_res)} of the {pie_count[0]}, {len(func_valid_res)} unknown functions are assigned.\") #len(final_res) + unknown_valid_num == pie_count[0]\n",
    "print(f\"{unknown_valid_num}/{useless_num} functions don't fit any of the three rules.\")\n",
    "print(takein_assign_num, takein_poss_num, takein_corr_num, \"functions are tried to fit for the three rules.\")\n",
    "print(f\"{good_assign_num} functions are assigned smoothly.\")\n",
    "print(f\"{bad_assign_num} functions are assigned with a bad grace.\")\n",
    "print(f\"{sum(force_assign)} functions are assigned forcibly: {force_assign[0]} are plused, {force_assign[1]} are possible, and {force_assign[2]} are CORR.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "384a31e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.75, 4.334905660377358, 12.584119496855347)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cold_ratio = [func_valid_res[func][\"cold\"][idx] for func, idx in final_res.items()]\n",
    "waste_ratio = [func_valid_res[func][\"waste\"][idx] for func, idx in final_res.items()]\n",
    "np.percentile(cold_ratio, 75), np.median(waste_ratio), np.percentile(waste_ratio, 75)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8396a09",
   "metadata": {},
   "source": [
    "### Record Corr candidate functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "25c5879b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "candi_func_tuplelst = defaultdict(list)\n",
    "all_corr_candi_num = 0\n",
    "\n",
    "candi_dist = [0] * TYPE_NUM\n",
    "\n",
    "for func, tri_tuple_lst in train_candi.items():\n",
    "    if func_class[func].type == CORR:\n",
    "        func_all_corr_candi = True\n",
    "    \n",
    "        for (candi, lag, _) in tri_tuple_lst:\n",
    "            if candi not in candi_func_tuplelst:\n",
    "                candi_dist[func_class[candi].type] += 1\n",
    "                \n",
    "            candi_func_tuplelst[candi].append((func, lag))\n",
    "            if func_class[candi].type != CORR:\n",
    "                func_all_corr_candi = False\n",
    "    \n",
    "        all_corr_candi_num += func_all_corr_candi\n",
    "\n",
    "all_corr_candi_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b18df67",
   "metadata": {},
   "source": [
    "## Show & Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "6b5c178e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|████████████████████████████████▋| 71000/71616 [00:00<00:00, 808012.92it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10223"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pie_count = [0] * (TYPE_NUM - 1)\n",
    "before_forget_pie_count = [0] * (TYPE_NUM - 1)\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func, arrcount in train_func_arrcount.items():\n",
    "        c += 1\n",
    "        if func_class[func].type > CORR:\n",
    "            func_class[func].type = 0\n",
    "            \n",
    "        pie_count[func_class[func].type] += 1\n",
    "        \n",
    "        if func_class[func].forget > 0:\n",
    "            before_forget_pie_count[0] += 1\n",
    "        else:\n",
    "            before_forget_pie_count[func_class[func].type] += 1\n",
    "        \n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "\n",
    "pie_count[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "1837ec66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "label_lst = ['Unknown','Warm', 'Regular', \"Appro-regular\", \"Dense\", \"Successive\", \"Plused\", \"Possible\", \"Corr\"]\n",
    "color_lst = ['#F5B3A2','#BC90B6','#2A4597','#DDC3C7', '#6A9C79', '#C5563B',\"#F1AB3D\", '#58A0A4','#E5F1E5',\"#FBDEAF\"]\n",
    "\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 4))\n",
    "plt.subplots_adjust(wspace=1, hspace =0)\n",
    "\n",
    "ax1.pie(np.array(before_forget_pie_count),\n",
    "        labels = label_lst,\n",
    "        colors = color_lst[:TYPE_NUM-1],\n",
    "        #explode = [0, 0.2, 0, 0, 0.7, 0, 0.1],\n",
    "        autopct='%.1f%%',\n",
    "        pctdistance=0.9,\n",
    "       )\n",
    "ax1.set_title('Before forgetting')\n",
    "\n",
    "ax2.pie(np.array(pie_count),\n",
    "        labels = label_lst,\n",
    "        colors = color_lst[:TYPE_NUM-1],\n",
    "        #explode = [0, 0.2, 0, 0, 0.7, 0, 0.1],\n",
    "        autopct='%.1f%%',\n",
    "        pctdistance=0.9,\n",
    "       )\n",
    "ax2.set_title('After forgetting')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a856600",
   "metadata": {},
   "source": [
    "#### Save categorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "86e40864",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs(\"mid-data\", exist_ok=True)\n",
    "with open(\"mid-data/train_info_assigned.txt\", \"w\") as wf:\n",
    "    for func, state in func_class.items():\n",
    "        wf.write(func+'\\t'+str(state.type)+'\\t'+str(state.forget)+'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ed6eec3",
   "metadata": {},
   "source": [
    "# Provision\n",
    "\n",
    "### Calculate basic info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "0ceb177a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [07:05<00:03, 166.96it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "additional_poss_num = 0\n",
    "\n",
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func in train_func_arrcount:\n",
    "        func_class[func].reset(True)\n",
    "        c += 1\n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "            \n",
    "        if func_class[func].type == WARM: continue\n",
    "            \n",
    "        func_class[func].pred_interval = [] #pred_value\n",
    "\n",
    "        arrcount = train_func_arrcount[func][1440*func_class[func].forget:]\n",
    "        func_class[func].last_call = np.where(np.array(arrcount)>0)[0][-1] - len(arrcount)\n",
    "        #assert func_class[func].last_call < 0\n",
    "\n",
    "        invok = conj_seq_lst(arrcount, count_invok=True)\n",
    "        non_invok = conj_seq_lst(arrcount)\n",
    "\n",
    "        func_class[func].wait_time = non_invok[-1] if arrcount[-1] == 0 else 0\n",
    "        func_class[func].pre_call_start = func_class[func].last_call - invok[-1] + 1\n",
    "\n",
    "        func_class[func].lasting_info = {\"max\": np.max(invok), \"seq_num\": len(invok)}\n",
    "        func_class[func].idle_info = {\"max\": np.max(non_invok), \"std\": np.std(non_invok), \"kind\": len(set(non_invok))}\n",
    "        \n",
    "        if func_class[func].type == REGULAR:\n",
    "            func_class[func].pred_interval = [np.median(non_invok)]\n",
    "        \n",
    "        else:\n",
    "            non_invok_unique, non_invok_counts = np.unique(non_invok, return_counts=True)\n",
    "            mode_cut = min(5, sum(np.where(non_invok_counts > 1, 1, 0)))\n",
    "            ordered_index = np.argsort(-non_invok_counts)\n",
    "            non_mode_max_index = ordered_index[: mode_cut]\n",
    "            \n",
    "            func_class[func].idle_info[\"mode\"] = non_invok_unique[non_mode_max_index].tolist() #In the order of occuring count\n",
    "            func_class[func].idle_info[\"mode_count\"] = non_invok_counts[non_mode_max_index].tolist()\n",
    "\n",
    "            if func_class[func].type == APPRO_REGULAR:\n",
    "                #func_class[func].pred_interval = non_invok_unique[ordered_index[: min(len(ordered_index), IDLE_NUM_MAX)]].tolist()\n",
    "                func_class[func].pred_interval = [non_invok_unique[idx] for idx in ordered_index[: min(len(ordered_index), IDLE_NUM_MAX)]\n",
    "                                                                        if non_invok_counts[idx] > 0.1 * sum(non_invok_counts)]\n",
    "                        \n",
    "            elif func_class[func].type == DENSE:\n",
    "                if len(non_mode_max_index) > 0:\n",
    "                    func_class[func].pred_interval = [min(func_class[func].idle_info[\"mode\"]),\n",
    "                        min(10, max(func_class[func].idle_info[\"mode\"]))]\n",
    "                else:\n",
    "                    func_class[func].pred_interval = [min(non_invok_unique), min(IDLE_NUM_MAX, max(non_invok_unique))]\n",
    "            \n",
    "            elif func_class[func].type == NEW_POSS:\n",
    "                func_class[func].type = 0\n",
    "            \n",
    "            if func_class[func].type == POSSIBLE or (func_class[func].type == UNKNOWN and len(non_mode_max_index) > 0):\n",
    "                additional_poss_num += (func_class[func].type == UNKNOWN)\n",
    "                func_class[func].type = POSSIBLE\n",
    "                if max(func_class[func].idle_info[\"mode\"]) - min(func_class[func].idle_info[\"mode\"]) <= DISCRETE_TH:\n",
    "                    func_class[func].pred_interval = [min(func_class[func].idle_info[\"mode\"]), \n",
    "                                                      max(func_class[func].idle_info[\"mode\"])]\n",
    "                    func_class[func].idle_info[\"pred_interval_discrete\"] = False\n",
    "                else: \n",
    "                    func_class[func].pred_interval = sorted(list(func_class[func].idle_info[\"mode\"]))\n",
    "                    func_class[func].idle_info[\"pred_interval_discrete\"] = True\n",
    "\n",
    "\n",
    "additional_poss_num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9924865",
   "metadata": {},
   "source": [
    "### Rank func & Load simulating corr & Reset\n",
    "\n",
    "#### Rank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "591e273c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(72359, 72359)"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_lst, func_corr_lst = set(), set()\n",
    "\n",
    "for func in func_class:\n",
    "    if func_class[func].type == CORR:\n",
    "        func_corr_lst.add(func)\n",
    "    else:\n",
    "        func_lst.add(func)\n",
    "\n",
    "for func in test_func_arrcount:\n",
    "    if func in func_class: continue\n",
    "    func_lst.add(func)\n",
    "    func_class[func] = func_state()\n",
    "\n",
    "func_lst, func_corr_lst = list(func_lst), list(func_corr_lst)\n",
    "\n",
    "len(func_class), len(func_lst)+len(func_corr_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6e0edbb",
   "metadata": {},
   "source": [
    "#### Load simulating corrlations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "7bcc9907",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_func_corr = defaultdict(set)\n",
    "\n",
    "for func, ownerapp in test_func_owner_app.items():\n",
    "    if func not in train_func_arrcount:\n",
    "        owner, app = ownerapp.split('\\t')\n",
    "        candi_func_set = (test_owner_func[owner] | test_app_func[app])\n",
    "        if len(candi_func_set) == 1: continue\n",
    "        \n",
    "        candi_func_set.remove(func)\n",
    "        for candi_func in candi_func_set:\n",
    "            if len(func_trigger[func] & func_trigger[candi_func]) > 0:\n",
    "                test_func_corr[func].add(candi_func)\n",
    "\n",
    "test_func_corr_perform = {func: {candi_func: 0} for candi_func in test_func_corr[func]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e28c0dcf",
   "metadata": {},
   "source": [
    "#### Reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f7f69cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "for func in test_func_arrcount:\n",
    "    if func in func_class and (func not in train_func_arrcount):\n",
    "        del func_class[func]\n",
    "    if func not in func_class:\n",
    "        func_class[func] = func_state()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "11c2242d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|███████████████████████████████████▋| 71000/71616 [06:50<00:03, 173.12it/s]\n"
     ]
    }
   ],
   "source": [
    "c = 0\n",
    "with tqdm(total=train_NUM) as pbar:\n",
    "    for func in train_func_arrcount:\n",
    "        func_class[func].reset(True)\n",
    "        c += 1\n",
    "        if c % shown_func_num == 0:\n",
    "            pbar.update(shown_func_num)\n",
    "            \n",
    "        if func_class[func].type == WARM: continue\n",
    "        arrcount = train_func_arrcount[func][1440*func_class[func].forget:]\n",
    "        func_class[func].last_call = np.where(np.array(arrcount)>0)[0][-1] - len(arrcount)\n",
    "        invok = conj_seq_lst(arrcount, count_invok=True)\n",
    "        non_invok = conj_seq_lst(arrcount)\n",
    "\n",
    "        func_class[func].wait_time = non_invok[-1] if arrcount[-1] == 0 else 0\n",
    "        func_class[func].pre_call_start = func_class[func].last_call - invok[-1] + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f5890ff",
   "metadata": {},
   "source": [
    "## Calculate predictive values & predictions at time 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "3ce15817",
   "metadata": {},
   "outputs": [],
   "source": [
    "PRE_WARM = 2\n",
    "EN_STD = 2\n",
    "\n",
    "GIVE_UP = {\n",
    "    UNKNOWN: POSS_GIVEUP,\n",
    "    WARM: 1440 * 14,\n",
    "    REGULAR: 1,\n",
    "    APPRO_REGULAR: 1,\n",
    "    DENSE: DENSE_UPPER_BOUND,\n",
    "    SUCCESSIVE: 1,\n",
    "    PLUSED: PLUSED_GIVEUP,\n",
    "    POSSIBLE: POSS_GIVEUP,\n",
    "    CORR: CORR_GIVEUP,\n",
    "    NEW_POSS: POSS_GIVEUP,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6db1c6a6",
   "metadata": {},
   "source": [
    "#### Predictive values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "981e2d04",
   "metadata": {},
   "outputs": [],
   "source": [
    "for func in train_func_arrcount: # calculate next invok start at time 0\n",
    "    _type = func_class[func].type\n",
    "\n",
    "    if _type == REGULAR: \n",
    "        p = func_class[func].last_call + 1\n",
    "        if p < 0:\n",
    "            p += (func_class[func].pred_interval[0] + 1)\n",
    "        func_class[func].next_invok_start = [(p - min(func_class[func].idle_info[\"std\"], EN_STD), \n",
    "                                              p + min(func_class[func].idle_info[\"std\"], EN_STD))]\n",
    "\n",
    "    elif _type == APPRO_REGULAR:\n",
    "        func_class[func].next_invok_start = [(func_class[func].last_call + p + 1, func_class[func].last_call + p + 1) \n",
    "                                                 for p in func_class[func].pred_interval]\n",
    "    elif _type == DENSE: \n",
    "        func_class[func].next_invok_start = [(func_class[func].last_call+func_class[func].pred_interval[0]+1,\n",
    "                                             func_class[func].last_call+func_class[func].pred_interval[1]+1)]\n",
    "    elif _type == CORR:\n",
    "        func_class[func].next_invok_start = defaultdict(list)\n",
    "        for (candi_func, lag, _ ) in train_candi[func]:\n",
    "            func_class[func].next_invok_start[candi_func].append(\n",
    "                (func_class[candi_func].last_call, func_class[candi_func].last_call + lag)\n",
    "            )\n",
    "            if func_class[candi_func].type != CORR: #otherwise, endless loop\n",
    "                func_class[func].next_invok_start[candi_func] += [(nis[0], nis[1] + lag) for nis in func_class[candi_func].next_invok_start]\n",
    "\n",
    "    elif _type in [POSSIBLE, NEW_POSS]:\n",
    "        if func_class[func].idle_info[\"pred_interval_discrete\"]:\n",
    "            func_class[func].next_invok_start = [(func_class[func].last_call + p + 1, func_class[func].last_call + p + 1) \n",
    "                                                       for p in func_class[func].pred_interval]\n",
    "        else:\n",
    "            func_class[func].next_invok_start = [(func_class[func].last_call+func_class[func].pred_interval[0]+1,\n",
    "                                            func_class[func].last_call+func_class[func].pred_interval[1]+1)]\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e249724e",
   "metadata": {},
   "source": [
    "#### Initialize memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "626a9e11",
   "metadata": {},
   "outputs": [],
   "source": [
    "memory = set()\n",
    "\n",
    "for func in train_func_arrcount: #Pre_warm for testing at time 0\n",
    "    _type = func_class[func].type\n",
    "    \n",
    "    if _type == WARM:\n",
    "        memory.add(func)\n",
    "        func_class[func].load(0)\n",
    "\n",
    "    elif _type in [SUCCESSIVE, CORR, POSSIBLE, NEW_POSS, UNKNOWN] and (func_class[func].last_call == -1):            \n",
    "        memory.add(func)\n",
    "        func_class[func].load(0)\n",
    "    \n",
    "    elif _type == PLUSED and (func_class[func].last_call + GIVE_UP[PLUSED] >= 0):\n",
    "        memory.add(func)\n",
    "        func_class[func].load(0)\n",
    "\n",
    "    elif _type in [REGULAR, APPRO_REGULAR, DENSE] and func_class[func].last_call == -1 \\\n",
    "        and (func_class[func].lasting_info[\"max\"] > 1 or func_class[func].lasting_info[\"seq_num\"] == 1):\n",
    "        memory.add(func)\n",
    "        func_class[func].load(0)\n",
    "\n",
    "    # Pre-warm funcs having next_invok_start\n",
    "    if _type == CORR:\n",
    "        flag = False\n",
    "        for _, tuple_lst in func_class[func].next_invok_start.items():\n",
    "            for (left, right) in tuple_lst:\n",
    "                if left <= PRE_WARM and right >= -PRE_WARM:\n",
    "                    memory.add(func)\n",
    "                    func_class[func].load(0)\n",
    "                    flag = True\n",
    "                    break\n",
    "            if flag: break\n",
    "                \n",
    "    elif _type in [REGULAR, APPRO_REGULAR, DENSE, POSSIBLE, NEW_POSS]:\n",
    "        for (left, right) in func_class[func].next_invok_start:\n",
    "            if left <= PRE_WARM and right >= -PRE_WARM:\n",
    "                memory.add(func)\n",
    "                func_class[func].load(0)\n",
    "                break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81626ced",
   "metadata": {},
   "source": [
    "# Simulating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "7b92b3bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "CORR_REMOVAL_TH = 2\n",
    "\n",
    "import bisect\n",
    "import random\n",
    "\n",
    "SHIFT = True #adaptive strategies\n",
    "func_cold = {func: 0 for func in test_func_arrcount}\n",
    "func_invok = {func: 0 for func in test_func_arrcount}\n",
    "\n",
    "func_invok_bool = {func: 0 for func in test_func_arrcount}\n",
    "func_waste = {func: 0 for func in test_func_arrcount}\n",
    "\n",
    "waste_mem_time = 0\n",
    "\n",
    "memory_size = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "804c4dbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████| 2880/2880 [15:37<00:00,  3.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WMT: 21521200 7472.638888888889\n",
      "Memory Usage 13982.138194444444 14167.5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.0, 0.10810810810810811, 0.6666666666666666)"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with tqdm(total=1440 * 2) as pbar:\n",
    "    for i in range(1440 * 2):\n",
    "        if (i+1) % 40 == 0:  pbar.update(40)\n",
    "        \n",
    "        random.shuffle(func_corr_lst)\n",
    "        for func in (func_lst + func_corr_lst): #In case of some functions staying in the memory forever\n",
    "            _type = func_class[func].type\n",
    "            \n",
    "            if func in test_func_arrcount and test_func_arrcount[func][i] > 0: #invok\n",
    "                func_invok[func] += test_func_arrcount[func][i]\n",
    "                func_invok_bool[func] += 1\n",
    "                \n",
    "                if not func_class[func].state: #cold start\n",
    "                    func_cold[func] += 1\n",
    "                    func_class[func].load(i)\n",
    "                    memory.add(func)\n",
    "                \n",
    "                if func_class[func].wait_time is None or func_class[func].wait_time > 0: #A new invocation seq begins currently\n",
    "                    func_class[func].pre_call_start = i\n",
    "                    func_class[func].adp_wait.append(func_class[func].wait_time)\n",
    "                    \n",
    "                    ## Shift: Update predictive values\n",
    "                    if SHIFT and (_type in [REGULAR, DENSE, POSSIBLE, NEW_POSS, UNKNOWN]) and len(func_class[func].adp_wait) >= 5: # Adaptively Updating\n",
    "                        if _type == REGULAR:\n",
    "                            if abs(np.median(func_class[func].adp_wait) - func_class[func].pred_interval[0]) > max(1, func_class[func].idle_info[\"std\"]):\n",
    "                                func_class[func].pred_interval[0] = (func_class[func].pred_interval[0]+np.median(func_class[func].adp_wait))/2\n",
    "                                \n",
    "                        elif _type == DENSE:\n",
    "                            if abs(min(func_class[func].adp_wait) - func_class[func].pred_interval[0]) > 1:\n",
    "                                func_class[func].pred_interval[0] = min(func_class[func].adp_wait)\n",
    "                            if (abs(max(func_class[func].adp_wait) - func_class[func].pred_interval[1]) > 1) \\\n",
    "                                and max(func_class[func].adp_wait) <= DENSE_UPPER_BOUND:\n",
    "                                func_class[func].pred_interval[1] = max(func_class[func].adp_wait)\n",
    "                        \n",
    "                        elif _type in [POSSIBLE, NEW_POSS]:\n",
    "                            idle_unique, idle_counts = np.unique(func_class[func].adp_wait, return_counts=True)\n",
    "                            if max(idle_counts) >= max(2, func_class[func].idle_info[\"mode_count\"][-1]):\n",
    "                                idle_max_index = np.argsort(-idle_counts)\n",
    "                                for idx in idle_max_index:\n",
    "                                    if idle_unique[idx] in func_class[func].idle_info[\"mode\"]: continue\n",
    "                                    pos = len(func_class[func].idle_info[\"mode_count\"]) - \\\n",
    "                                            bisect.bisect(func_class[func].idle_info[\"mode_count\"][::-1], idle_counts[idx])\n",
    "                                    if pos >= len(func_class[func].idle_info[\"mode_count\"]): continue\n",
    "                                        \n",
    "                                    if idle_counts[idx] > func_class[func].idle_info[\"mode_count\"][pos]:\n",
    "                                        func_class[func].idle_info[\"mode_count\"][pos] = idle_counts[idx]\n",
    "                                        func_class[func].idle_info[\"mode\"][pos] = idle_unique[idx]\n",
    "                                    elif idle_counts[idx] == func_class[func].idle_info[\"mode_count\"][pos]:\n",
    "                                        func_class[func].idle_info[\"mode_count\"].insert(pos, idle_counts[idx])\n",
    "                                        func_class[func].idle_info[\"mode\"].insert(pos, idle_unique[idx])\n",
    "\n",
    "                                \n",
    "                                if max(func_class[func].idle_info[\"mode\"]) - min(func_class[func].idle_info[\"mode\"]) <= DISCRETE_TH:\n",
    "                                    func_class[func].pred_interval = [min(func_class[func].idle_info[\"mode\"]), \n",
    "                                                      max(func_class[func].idle_info[\"mode\"])]\n",
    "                                    func_class[func].idle_info[\"pred_interval_discrete\"] = False\n",
    "                                else: \n",
    "                                    func_class[func].pred_interval = sorted(list(func_class[func].idle_info[\"mode\"]))\n",
    "                                    func_class[func].idle_info[\"pred_interval_discrete\"] = True\n",
    "                                \n",
    "                        elif _type == UNKNOWN:\n",
    "                            idle_unique, idle_counts = np.unique(func_class[func].adp_wait, return_counts=True)\n",
    "                            idxs = np.argsort(-idle_counts)[: min(5, sum(np.where(idle_counts > 1, 1, 0)))]\n",
    "                            mode_lst = idle_unique[idxs]\n",
    "                            if len(mode_lst) > 0:\n",
    "                                func_class[func].type = NEW_POSS\n",
    "                                func_class[func].idle_info[\"mode\"] = mode_lst.tolist()\n",
    "                                func_class[func].idle_info[\"mode_count\"] = idle_counts[idxs].tolist()\n",
    "                                \n",
    "                                if max(mode_lst) - min(mode_lst) <= DISCRETE_TH:\n",
    "                                    func_class[func].idle_info[\"pred_interval_discrete\"] = False\n",
    "                                    func_class[func].pred_interval = [min(mode_lst), max(mode_lst)]\n",
    "                                else:\n",
    "                                    func_class[func].idle_info[\"pred_interval_discrete\"] = True\n",
    "                                    func_class[func].pred_interval = sorted(list(mode_lst))\n",
    "                                \n",
    "                func_class[func].wait_time = 0\n",
    "                func_class[func].last_call = i\n",
    "                \n",
    "                #Update prediction for UNI, LIMITIDLE, DENSE, DIVI\n",
    "                if _type == REGULAR:\n",
    "                    func_class[func].next_invok_start = [(i + 1 + func_class[func].pred_interval[0] - min(func_class[func].idle_info[\"std\"], EN_STD),\n",
    "                                                          i + 1 + func_class[func].pred_interval[0] + min(func_class[func].idle_info[\"std\"], EN_STD))]\n",
    "                        \n",
    "                elif _type == APPRO_REGULAR or (_type in [POSSIBLE, NEW_POSS] and func_class[func].idle_info[\"pred_interval_discrete\"]):\n",
    "                    func_class[func].next_invok_start = [(i + p + 1, i + p + 1) for p in func_class[func].pred_interval]\n",
    "                \n",
    "                elif _type == DENSE or (_type in [POSSIBLE, NEW_POSS] and (not func_class[func].idle_info[\"pred_interval_discrete\"])):\n",
    "                    func_class[func].next_invok_start = [(i + func_class[func].pred_interval[0] + 1, i + func_class[func].pred_interval[1] + 1)]\n",
    "                \n",
    "                #The occurrences of candidate functions can be predictive indicators.\n",
    "\n",
    "                if func in candi_func_tuplelst: \n",
    "                    for (target_func, lag) in candi_func_tuplelst[func]: #func is candi, target is target\n",
    "                        func_class[target_func].next_invok_start[func] = [(i, i + lag)]\n",
    "                        if _type in [REGULAR, APPRO_REGULAR, DENSE, POSSIBLE, NEW_POSS]:\n",
    "                            func_class[target_func].next_invok_start[func] += [(l, r + lag) \n",
    "                                                                             for (l, r) in func_class[func].next_invok_start]\n",
    "                if func in test_func_corr:\n",
    "                    for target_func in test_func_corr[func]:\n",
    "                        if func_class[target_func].type == CORR:\n",
    "                            func_class[target_func].next_invok_start[func] += [(i, i + 1)]\n",
    "                            func_class[target_func].next_invok_start[func] = list(set(func_class[target_func].next_invok_start[func]))\n",
    "                        else:\n",
    "                            #assert not isinstance(func_class[post_func].next_invok_start, dict), post_func\n",
    "                            func_class[target_func].next_invok_start += [(i, i + 1)]\n",
    "                            func_class[target_func].next_invok_start = list(set(func_class[target_func].next_invok_start))\n",
    "                        \n",
    "            else: # not invok\n",
    "                #func_class[func].cal_idle()\n",
    "                if func_class[func].wait_time is None:\n",
    "                    func_class[func].wait_time = 1\n",
    "                else:\n",
    "                    func_class[func].wait_time += 1\n",
    "                    \n",
    "                if func in memory:\n",
    "                    waste_mem_time += 1\n",
    "                    if func in func_waste:\n",
    "                        func_waste[func] += 1\n",
    "                \n",
    "                # Prewarm according to different types\n",
    "                pre_warm_flag = False\n",
    "                \n",
    "                if _type == REGULAR:\n",
    "                    (p_small, p_large) = func_class[func].next_invok_start[0]\n",
    "                    p_small += (func_class[func].pred_interval[0] + 1) * int(p_large <= i) #allow for one missing hit\n",
    "                    func_class[func].next_invok_start[0] = (p_small, p_small + 2 * min(func_class[func].idle_info[\"std\"], EN_STD))\n",
    "\n",
    "                if _type in [REGULAR, APPRO_REGULAR, DENSE, POSSIBLE, NEW_POSS, UNKNOWN]:\n",
    "                    for (left, right) in func_class[func].next_invok_start:\n",
    "                        if left <= i + PRE_WARM and right >= i - PRE_WARM:\n",
    "                            pre_warm_flag = True\n",
    "                            break\n",
    "\n",
    "                elif _type == CORR:\n",
    "                    for tuple_lst in func_class[func].next_invok_start.values():\n",
    "                        for (left, right) in tuple_lst:\n",
    "                            if left <= i + PRE_WARM and right >= i - PRE_WARM:\n",
    "                                pre_warm_flag = True\n",
    "                                break\n",
    "                        if pre_warm_flag: break\n",
    "                \n",
    "                if func_class[func].state and (not pre_warm_flag) and func_class[func].wait_time >= GIVE_UP[_type]: #Remove\n",
    "                    memory.remove(func)\n",
    "                    func_class[func].unload()\n",
    "                \n",
    "                elif pre_warm_flag:\n",
    "                    memory.add(func)\n",
    "                    func_class[func].load(i)\n",
    "\n",
    "        memory_size.append(len(memory))\n",
    "        \n",
    "        ## Update test_corr\n",
    "        for func, perform_dict in test_func_corr_perform:\n",
    "            for candi in perform_dict:\n",
    "                test_func_corr_perform[func][candi] += int(bool(test_func_arrcount[func][i]) & bool(test_func_arrcount[candi][i]))\n",
    "        \n",
    "        for func, perform_dict in test_func_corr_perform.items():\n",
    "            best_perform = max(perform_dict.values())\n",
    "            del_lst = []\n",
    "            for candi, perform in perform_dict:\n",
    "                if best_perform - perform >= CORR_REMOVAL_TH:\n",
    "                    del_lst.append(candi)\n",
    "            for candi in del_lst:\n",
    "                del test_func_corr[func][candi]\n",
    "                del test_func_corr_perform[func][candi]\n",
    "        \n",
    "cold_ratio = [cold/func_invok[func] for func, cold in func_cold.items()]\n",
    "print(\"WMT:\", waste_mem_time, waste_mem_time/2880)\n",
    "print(\"Memory Usage\", np.mean(memory_size), np.median(memory_size))\n",
    "np.percentile(cold_ratio, 50), np.percentile(cold_ratio, 75), np.percentile(cold_ratio, 90)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4e73e61",
   "metadata": {},
   "source": [
    "# Result Save & Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "c7cb79d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "def read_json(filepath):\n",
    "    if os.path.exists(filepath):\n",
    "        assert filepath.endswith('.json')\n",
    "        with open(filepath, 'r') as f:\n",
    "            return json.loads(f.read())\n",
    "    else: \n",
    "        print(\"File path \"+filepath+\" not exists!\")\n",
    "        return\n",
    "    \n",
    "def json_pretty_dump(obj, filename):\n",
    "    with open(filename, \"w\") as fw:\n",
    "        json.dump(obj,fw, sort_keys=True, indent=4, separators=(\",\", \": \"), ensure_ascii=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "ec99d4d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "os.makedirs(\"../result\", exist_ok=True)\n",
    "\n",
    "cur_time = time.strftime(\"%d-%H-%M\", time.localtime())\n",
    "\n",
    "json_pretty_dump(func_cold, f\"../result/func_cold_{cur_time}.json\")\n",
    "json_pretty_dump(func_waste, f\"../result/func_waste_{cur_time}.json\")\n",
    "json_pretty_dump(func_invok, f\"../result/func_invok_{cur_time}.json\")\n",
    "json_pretty_dump(memory_size, f\"../result/memory_size_{cur_time}.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20cc3288",
   "metadata": {},
   "source": [
    "## Anlysis\n",
    "\n",
    "#### Cold start of each type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "29c06be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "aim = np.percentile(cold_ratio, 75)\n",
    "label_lst = ['Unknown','Warm', 'Regular', \"Appro-regular\", \"Dense\", \"Successive\", \"Plused\", \"Possible\", \"Corr\", \"New_poss\"]\n",
    "\n",
    "cold_num_per_type = [0] * TYPE_NUM\n",
    "invok_num_per_type = [0] * TYPE_NUM\n",
    "cold_ratio_per_type_lst = [[] for _ in range(TYPE_NUM)]\n",
    "\n",
    "for func, cold in func_cold.items():\n",
    "    cold_num_per_type[func_class[func].type] += cold\n",
    "    invok_num_per_type[func_class[func].type] += func_invok[func]\n",
    "    cold_ratio_per_type_lst[func_class[func].type].append(cold / func_invok[func])\n",
    "\n",
    "cold_ratio_exceed_num, cold_ratio_exceed_rate, cold_ratio75 =[0]*TYPE_NUM, [0]*TYPE_NUM, [0]*TYPE_NUM\n",
    "\n",
    "for i, lst in enumerate(cold_ratio_per_type_lst):\n",
    "    if len(lst) > 0:\n",
    "        cold_ratio_exceed_num[i] = sum(np.where(np.array(lst)>=aim, 1, 0))\n",
    "        cold_ratio_exceed_rate[i] = sum(np.where(np.array(lst)>=aim, 1, 0))/len(lst)\n",
    "        cold_ratio75[i] = np.percentile(lst, 75)\n",
    "    else:\n",
    "        print(f\"Empty Type {i}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ca8b81c",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1, ax2, ax3, ax4) = plt.subplots(nrows=4, figsize=(10, 12))\n",
    "plt.subplots_adjust(wspace=0, hspace=0.3)\n",
    "\n",
    "ax1.bar(range(TYPE_NUM), \n",
    "        cold_num_per_type, \n",
    "        color=color_lst[:TYPE_NUM], \n",
    "        tick_label=label_lst\n",
    "        )\n",
    "ax1.set_title('Cold Start Num')\n",
    "\n",
    "ax2.bar(range(TYPE_NUM), \n",
    "        invok_num_per_type, \n",
    "        color=color_lst[: TYPE_NUM], \n",
    "        tick_label=label_lst\n",
    "        )\n",
    "ax2.set_title('Invocation Num')\n",
    "\n",
    "ax3.bar(range( TYPE_NUM), \n",
    "        cold_ratio_exceed_num, \n",
    "        color=color_lst[: TYPE_NUM],  \n",
    "        tick_label=label_lst\n",
    "        )\n",
    "ax3.set_title('Cold Start Exceed Num')\n",
    "\n",
    "ax4.bar(range( TYPE_NUM), \n",
    "        cold_ratio_exceed_rate, \n",
    "        color=color_lst[: TYPE_NUM],  \n",
    "        tick_label=label_lst\n",
    "        )\n",
    "ax4.set_title('Cold Start Exceed Ratio')\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "082dd515",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}