2022-08-10 10:16:12 +02:00
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# Verification frequency calculation\n",
"\n",
"This code shows how we can compute the minimum horizontal and vertical verification frequency in order to achieve a certain level of guarantee computed in number of nines (e.g., 99.9999999%)\n"
],
"metadata": {
"id": "IAw0wWuN-1Yh"
}
},
{
"cell_type": "code",
"source": [
"import numpy as np\n",
"import random as random\n",
"import matplotlib.pyplot as plt\n",
"\n",
"#@markdown Durability guarantee (three 9s (99.9%) to nine 9s (99.9999999%))\n",
"Durability = 9 #@param {type:\"slider\", min:3, max:9, step:3}\n",
"#@markdown Erasure Coding parameter K\n",
"ECK = 60 #@param {type:\"slider\", min:1, max:100, step:1}\n",
"#@markdown Number of PoR blocks inside an EC block (See model below)\n",
2022-09-21 15:05:59 +02:00
"NbPoRinEC = 1000 #@param {type:\"slider\", min:100, max:10000, step:100}\n",
2022-08-10 10:16:12 +02:00
"\n",
2022-09-21 15:05:59 +02:00
"CheatRatio = [1, 5, 10, 50]\n",
2022-08-10 10:16:12 +02:00
"GuaranteeDurability = {3:99.90, 6: 99.99990, 9: 99.99999990}\n",
"ExpectedGuarantee = GuaranteeDurability[Durability]\n",
"\n",
"hx = []\n",
"HorizontalProb = []\n",
2022-09-21 15:05:59 +02:00
"HorizontalResults = {3:0, 6:0, 9:0}\n",
2022-08-10 10:16:12 +02:00
"for NbOfHVerif in range(ECK):\n",
" prob = (1-(((ECK-1)/100)**NbOfHVerif))*100\n",
" hx.append(NbOfHVerif)\n",
" HorizontalProb.append(prob)\n",
2022-09-21 15:05:59 +02:00
" if prob > GuaranteeDurability[3] and HorizontalResults[3] == 0:\n",
" HorizontalResults[3] = NbOfHVerif\n",
" if prob > GuaranteeDurability[6] and HorizontalResults[6] == 0:\n",
" HorizontalResults[6] = NbOfHVerif\n",
" if prob > GuaranteeDurability[9] and HorizontalResults[9] == 0:\n",
" HorizontalResults[9] = NbOfHVerif\n",
" \n",
"print(\"We need %d horizontal verifications to have %12.12f%% guarantee\" % (HorizontalResults[3], GuaranteeDurability[3]))\n",
"print(\"We need %d horizontal verifications to have %12.12f%% guarantee\" % (HorizontalResults[6], GuaranteeDurability[6]))\n",
"print(\"We need %d horizontal verifications to have %12.12f%% guarantee\" % (HorizontalResults[9], GuaranteeDurability[9]))\n",
" \n",
"\n",
"c = 1\n",
"VerticalResults = {3:0, 6:0, 9:0}\n",
"vx = range(NbPoRinEC)\n",
"VerticalProb = []\n",
"for i in range(len(CheatRatio)):\n",
" VProb = [0]\n",
" for NbOfVVerif in range(1, NbPoRinEC):\n",
" prob = (1-((1-(CheatRatio[i]/100))**NbOfVVerif))*100\n",
" VProb.append(prob)\n",
" if i == c:\n",
" if prob > GuaranteeDurability[3] and VerticalResults[3] == 0:\n",
" VerticalResults[3] = NbOfVVerif*100/NbPoRinEC\n",
" #print(\"Probability of detecting catastrophic failures with %d vertical verifications %12.12f%% (Over nine 9s)\" % (NbOfVVerif, prob))\n",
" #print(\"That is %2.1f%% of the PoR blocks need to be verified\" % (NbOfVVerif*100/NbPoRinEC))\n",
" if prob > GuaranteeDurability[6] and VerticalResults[6] == 0:\n",
" VerticalResults[6] = NbOfVVerif*100/NbPoRinEC\n",
" #print(\"Probability of detecting catastrophic failures with %d vertical verifications %12.12f%% (Over nine 9s)\" % (NbOfVVerif, prob))\n",
" #print(\"That is %2.1f%% of the PoR blocks need to be verified\" % (NbOfVVerif*100/NbPoRinEC))\n",
" if prob > GuaranteeDurability[9] and VerticalResults[9] == 0:\n",
" VerticalResults[9] = NbOfVVerif*100/NbPoRinEC\n",
" #print(\"Probability of detecting catastrophic failures with %d vertical verifications %12.12f%% (Over nine 9s)\" % (NbOfVVerif, prob))\n",
" #print(\"That is %2.1f%% of the PoR blocks need to be verified\" % (NbOfVVerif*100/NbPoRinEC))\n",
" VerticalProb.append(VProb)\n",
"\n",
"print(\"For Cheat Ratio : %d\" % CheatRatio[c])\n",
"print(\"We need %2.1f%% vertical verifications to have %12.12f%% guarantee\" % (VerticalResults[3], GuaranteeDurability[3]))\n",
"print(\"We need %2.1f%% vertical verifications to have %12.12f%% guarantee\" % (VerticalResults[6], GuaranteeDurability[6]))\n",
"print(\"We need %2.1f%% vertical verifications to have %12.12f%% guarantee\" % (VerticalResults[9], GuaranteeDurability[9]))\n",
2022-08-10 10:16:12 +02:00
"\n",
"\n",
"fig, ax = plt.subplots()\n",
"plt.grid(axis='x', color='0.9')\n",
"plt.grid(axis='y', color='0.9')\n",
"plt.title(\"Number of horizontal verifications to reach %9.9f guarantee on durability\" % ExpectedGuarantee)\n",
"plt.xlabel(\"Nodes verified from K=%d in the EC\" % ECK)\n",
"plt.ylabel(\"Guarantee of not having catastrophic failures (%)\")\n",
"ax.plot(hx, HorizontalProb)\n",
"#plt.yscale('log')\n",
"plt.show()\n",
"plt.clf()\n",
"\n",
2022-09-21 15:05:59 +02:00
"color = [\"blue\", \"green\", \"orange\", \"red\"]\n",
2022-08-10 10:16:12 +02:00
"fig, ax = plt.subplots()\n",
"plt.grid(axis='x', color='0.9')\n",
"plt.grid(axis='y', color='0.9')\n",
"plt.title(\"Number of vertical verifications to reach %9.9f guarantee on durability\" % ExpectedGuarantee)\n",
"plt.xlabel(\"Number of PoR blocks verified out of %d\" % NbPoRinEC)\n",
"plt.ylabel(\"Guarantee of not having catastrophic failures (%)\")\n",
2022-09-21 15:05:59 +02:00
"for i in range(len(CheatRatio)):\n",
" ax.plot(vx, VerticalProb[i], label = CheatRatio[i], color = color[i])\n",
2022-08-10 10:16:12 +02:00
"#plt.yscale('log')\n",
2022-09-21 15:05:59 +02:00
"ax.legend()\n",
2022-08-10 10:16:12 +02:00
"plt.show()\n",
"\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000
},
"id": "Y_CIsSJz_Nek",
2022-09-21 15:05:59 +02:00
"outputId": "7a352dbc-9ee6-4c3b-db37-79600fe8b1b7"
2022-08-10 10:16:12 +02:00
},
2022-09-21 15:05:59 +02:00
"execution_count": null,
2022-08-10 10:16:12 +02:00
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
2022-09-21 15:05:59 +02:00
"We need 14 horizontal verifications to have 99.900000000000% guarantee\n",
"We need 27 horizontal verifications to have 99.999900000000% guarantee\n",
"We need 40 horizontal verifications to have 99.999999900000% guarantee\n",
"For Cheat Ratio : 5\n",
"We need 13.5% vertical verifications to have 99.900000000000% guarantee\n",
"We need 27.0% vertical verifications to have 99.999900000000% guarantee\n",
"We need 40.5% vertical verifications to have 99.999999900000% guarantee\n"
2022-08-10 10:16:12 +02:00
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1080x576 with 1 Axes>"
],
2022-09-21 15:05:59 +02:00
"image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAHwCAYAAAAfJXbRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5xdZZ348c93JpPeEwKEFKqCsKgQpIiuXWy4a8G+yKroWrdZd1FcXXXd9sOGYltsC4isDde6gLsqSoLSRRCZJCQkJDNpM0kmM/P9/XHOwM0w5U65cyczn/frdV/33lO/99xnzpzvfZ7zPJGZSJIkSZImloZ6ByBJkiRJGn0me5IkSZI0AZnsSZIkSdIEZLInSZIkSROQyZ4kSZIkTUAme5IkSZI0AZnsSRNQRPxHRHywTvuOiPhiRLRGxK/6mP/qiPi/UdzfeyLic6O1vdEQEddGxGvHaF+7IuLI8vWMiPhORGyPiK9HxCsi4oc12OcTIuLO0d7uRDCW37003tSy/EfEkyJi/QDzPx0RF/S1bETcFhFPqkVc0nhnsieNgYi4NyI2R8SsimmvjYhr6xhWrZwJPB1YlpmPq/XOMvNDmVnTi+uIyIg4upb7GK7MnJ2Z95RvXwQcDCzKzBdn5lcz8xkj3Ufvz5+Z/5uZjxzpdocYw4RMosrzwN1l0v79iFhaMW9+RFxanjs2R8SFtdpWRJwREb+KiJ0RcXNEnFkxLyLi7yJibUTsiIjLImJuxfzDIuJbEdESEesj4g29tv28iLi1jOvnEfGoinnTIuLfI2JD+QPRpyKiqWL+woj4r4hoi4jmiHh5r22/vJzeFhHfjIiF1Rz38SwiDi//5qbUO5YDSWa+ITM/0M+84zPzWoCIuDAivjKmwUl1ZLInjZ1G4G31DmKoIqJxiKusBO7NzLZaxFNpMl8M9fPZVwK/y8zOsY7nQDJeyk1Z0/Ah4PnAQuAPwH9WLPLvwEzgcOBxwKsi4rzR3laZIH0H+GdgPvBR4DsRsaBc98+AVwGPB5YCM4CPV2z7K+X+DgaeA3woIp5cbvsY4KvAG8ptfwf4dsV38C5gFXAC8AjgJODvK7b9SaCj3PYrgIsj4vhy28cDnyljOxhoBz7V1/EZS+OlfB1Iyh8UvCaVaiEzffjwUeMHcC/FRU0LML+c9lrg2vL14UACUyrWuRZ4bfn61cDPKC7YtgH3AGeU09cBm4FzK9b9D+DTwI+AncB1wMqK+ceW81qAO4Fzeq17MfA9oA14Wh+fZynw7XL9u4HXldNfA+wBuoBdwPv7WPfVwP8B/wK0UlwkPmuwbZfzLgSupLi43FEewwuBr5TzP1Hut+fRCVxYzjuuPKbbgNuAs3t95k8CV5fH65fAUeW8n5bfTVu5zZcAC4DvAg+Un+G7FDWZD/vu+jhuu4GFFdMeC2wBmsr3fw7cUW73B72+twTeBNwF/KFi2tHA+ykuiveVcb6m51hXrH98xfe+CXhPOf1xwC/KY7OxPI5TB/j8TwLWV2x3uMc2KMr05vL7vAU4oY/j9o8UZWpPGcMnyulnADcA28vnMwb5G3wncDOwF5gCnAb8vIz7JuBJFcufV34POyn+3l7fa3vPB35Txv174KyK7/4DFH+vO4EfAov7ielfgE/2Kh9ZcXy2AKdUzH8P8L+jvS3gucBtvbb3O+A15esrgbdXzDuj/C5mArPL/RxUMf8S4Mvl6zcDV1fMa6D4G3hq+X418OKK+S8H1pWvZ1GU6UdUzP8y8JHy9YeAr1XMO6pcfk4/x+gZFOe77RRJ4XU8dI69kPI80tc5eaDyQPn3UJav+8sYqzlH9FlOgLXlvnvOY6dXcW7o95xe7fm74jhcAXypjOs2YNUA23o68NvymH5iiMf0Woq/7Z+VZeLoKo/zeyjK873AK3qdaz5YuWyvv/+nAWex/3nyJuDFwJpen+uvgW/197l9+DiQHv6KIo2d1RT/3P52mOufSnGhugj4GnAZcArFP8hXAp+IiNkVy7+C4mJiMcVF6VcByqakPyq3sQR4KfCpyqZVFBdc/wjMoUjMeruM4p/uUoqmgx+KiKdk5ucpfsH/RRbNC983wGe5s4zto8DnIyIG2nbFus+nuPic3/OZemTmm8v9zqZoTtoKfKtsFvYdiguqJcBbgK9GRGVTxJdSJEwLKC6A/rHc5hPL+Y8ut305xQXrFylq0lZQXKh8op/PWhnfBoqk6oUVk18OXJmZ+yLi+RQXMi8ADgL+l/1rZwD+hOL4VX5flMf6Q8DlZZyfr5wfEXOAHwPfpzi2RwM/KWd3AX9F8X2cDjwVeOMAn79yu8M+thQX30+kqNGZB5wDbO3juP1deSx6vt83l7VRVwMfo/ib+Dfg6ohY1Hv9Ci+jqHmaT1ETdDXwQYqasL8FvhERB5XLbqZIguZSXID+e0ScVH7mx1FcDL+93NYTKS4me7y8XGcJMJWB/+ajj9cnDDC/ct5obqty3mDzA5gGHFMxvdptRxXzl0XEPIpy0ZmZv6uYfxPFjxaUzzf1zMjM31Mmh70+CxGxmOK88W6K8nInRdJarX7LQ+kQinK0Ejif6s4R/ZWTnr+5+WV5/8VA54Yqz+mVBjvHnl0uM58iKezz3FYe06soamIXU/zo8fh+9tmfV1EcrzlAM9Ud58XAYcC5wCW9zjUDyszvs/958tEUn/GIiDiuV1xfGuJnkcYlkz1pbL0XeEvFBeVQ/CEzv5iZXcDlwHLgHzJzb2b+kOIip/K+sqsz86eZuRf4O+D0iFhO8Y/03nJbnZn5a+AbFL9u9vhWZv4sM7szc09lEOU2Hg+8MzP3ZOZvgM9RNPWqVnNmfrb8LJcChwIHV7ntX2TmN8vYdve18fL4fhN4S/n5TqOogfhIZnZk5v9Q/NL+sorV/iszf5VFE8ivAo/pL/jM3JqZ38jM9szcSZG8/HGVn/1rPfstE9yXltOgSJQ/nJl3lHF8CHhMRKysWP/DmdnS32cfwHOB+zPzX8tjuzMzf1l+njWZeX1ZHu6laBpX7ecZybHdR3GRdywQ5efeWOV+nwPclZlfLuP+T4oahucNsM7HMnNdeexeCXwvM79XlqUfUfwg82yAzLw6M3+fhesoktknlNt5DfCFzPxRue59mfnbiv18MTN/V+7nCvovS98HzomIEyNiBsX5ISlqzHrmvysi5kRxz+SfV8wbzW39AlgaES+LiKaIOJeilqxy3deW95LNo6jBAphZlv+fARdExPTywvyFFev+GPjjKDrMmEqRsEztte23RcRBEXEI8NaebVOUqx29Pud2ijJDOX/7APMrPZui9vKqshx+jKIWriqDlAeAbuB95fl4d5XniGrLCQx8bqjmnA5Uff7+v/LvoouilvLR/cTUc0yvzMx9wP9jCMe09B+ZeVsZ974qjjPABeVxvo7iB5tzhrjP/ZT/Iy+nOCf0NA8+nOI8Jh3wTPakMZSZt1L8A3nXMFbfVPF6d7m93tMqa/bWVex3F0WTnaUUvzSfGhHbeh4UtYCH9LVuH5YCLeUFTI9mil9aq/XgBUFmtpcvZ1e57YFi66lpupKieddlFTGvy8zuAbZbeZHSzv7Hsvc+ZkbEZ8qOIXZQNHWcX+X9jd+gSLwPpfgFv5viV3oovpuLKr6XFoqajqo//wCWU/zy/jAR8YiI+G5E3F9+ng9R/HpejWEf2zIx/ARFM8/NEXFJVHT8UcV+m3tNG6wcVh67lcCLe/0dnEnxwwMR8ayIuD6KTke2UVzY9hyTfo9lqaqylJk/Bt5HUSbuLR87KWpdoEh8dlM02/0WRU1On70RjmRbmbmVosb8rynOM2dRJGk9636hXP5aimZ915TTe+a/AjiC4vheTNHMumfbv6WogfkERRPhxcDtFev+I/BritYHP6f4kWZfGccuihqeSnPLz0UV8ystZf9zYtLPsezLIOUB4IHKH8aqPEdUfc5h4HNDNef0HtWcY3vHNb2f+xD7OqZDPT/tt3wVx7k1978fvLmMY6QuBV5e/gD3KuCKMgmUDngme9LYex/wOvb/59rzz6vyV/u+/
2022-08-10 10:16:12 +02:00
},
"metadata": {
"needs_background": "light"
}
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1080x576 with 0 Axes>"
]
},
"metadata": {}
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1080x576 with 1 Axes>"
],
2022-09-21 15:05:59 +02:00
"image/png": "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
2022-08-10 10:16:12 +02:00
},
"metadata": {
"needs_background": "light"
}
}
]
},
2022-09-21 15:05:59 +02:00
{
"cell_type": "markdown",
"source": [
"100 blocks\n",
"cheat ratio is 50%\n",
"only storing 50 blocks\n",
"\n",
"Probability of you passing the verification for\n",
"\n",
"1 block : 0.5\n",
"2 blocks : 0.5*0.5 = 0.25\n",
"3 blocks : 0.5*0.5*0.5\n",
"\n",
"n blocks : 0.5^n"
],
"metadata": {
"id": "7vid6VP3a_oM"
}
},
2022-08-10 10:16:12 +02:00
{
"cell_type": "markdown",
"source": [
"# PoR Analysis\n",
"\n",
"## Friendly toy scenario\n",
"\n",
"Feel free to play with these variables as much as you want in order to simulate any extreme scenario you find interesting to explore."
],
"metadata": {
"id": "Bw-GGBdX6tMm"
}
},
{
"cell_type": "code",
2022-09-21 15:05:59 +02:00
"execution_count": null,
2022-08-10 10:16:12 +02:00
"metadata": {
"colab": {
2022-09-21 15:05:59 +02:00
"base_uri": "https://localhost:8080/",
"height": 1000
2022-08-10 10:16:12 +02:00
},
"id": "n-GB9Vsmp4M1",
2022-09-21 15:05:59 +02:00
"outputId": "5f0f0f7c-964d-4ad3-baa9-c3ed272a3912"
2022-08-10 10:16:12 +02:00
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"\n",
" *** Network Parameters *** \n",
"\n",
"The network has 15400 nodes\n",
"The average node capacity is 1200 GBs\n",
"The network has 1206000 files\n",
"The average file size in the network is 9765 MBs\n",
2022-09-21 15:05:59 +02:00
"The estimated mean time between failures of the network is 1 hours\n",
2022-08-10 10:16:12 +02:00
"Malicious nodes cheat the system by NOT storing 5% of the data they should store\n",
"\n",
" *** Codex Parameters *** \n",
"\n",
"The erasure coding parameter K is 60\n",
"The erasure coding parameter M is 40\n",
"The lazy repair parameter L is 20\n",
2022-09-21 15:05:59 +02:00
"The Proof of Retrievability number of sectors per block is 1000\n",
2022-08-10 10:16:12 +02:00
"The PoR agregation cost is 1 ms per PoR block\n",
"Durability in number of nines: 9\n",
"\n",
" *** Dataset and block structures *** \n",
"\n",
"There are 1206000 files of size 10000000 KB (9765.6 MB)\n",
"The total storage used in the network is 11231.8 TB and there is 6815.1 TB of available storage for a total of 18046.9 TB\n",
"There will be 100 EC blocks of size 162.8 MBs per file\n",
"There is a total of 120600000 EC blocks in the network\n",
"There is an average of 7831.2 EC blocks per node (assuming an homogeneous distribution)\n",
2022-09-21 15:05:59 +02:00
"Each EC block has 5505.4 PoR blocks of size 30.3 KB\n",
2022-08-10 10:16:12 +02:00
"\n",
" *** Durability guarantees and verification frequency *** \n",
"\n",
2022-09-21 15:05:59 +02:00
"We need 14 horizontal verifications to have 99.900000000000% guarantee\n",
"We need 27 horizontal verifications to have 99.999900000000% guarantee\n",
"We need 40 horizontal verifications to have 99.999999900000% guarantee\n",
"For Cheat Ratio : 5\n",
"We need 2.5% vertical verifications to have 99.900000000000% guarantee\n",
"We need 4.9% vertical verifications to have 99.999900000000% guarantee\n",
"We need 7.4% vertical verifications to have 99.999999900000% guarantee\n",
"\n",
2022-08-10 10:16:12 +02:00
"Guarantee of data durability is 99.999999900\n",
"The PoR horizontal verification factor is 40.0\n",
"The PoR vertical verification factor is 7.4%\n",
"\n",
" *** PoR Storage and Time Requirements *** \n",
"\n",
2022-09-21 15:05:59 +02:00
"The total storage required for PoR proofs is 1426162.7 MB to check a total of 11231.8TB of data each round\n",
2022-08-10 10:16:12 +02:00
"To verify 40 EC blocks and 7.4% PoR blocks per file in the system:\n",
"Each node will spend 2114.4 minutes (35.2 hours) agregating PoR proofs\n",
2022-09-21 15:05:59 +02:00
"It will take the system 40 hours (1.7 days) to accidentally lose M nodes\n",
"Lazy repair should be triggered after 20 hours (0.8 days)\n",
"Assuming PoR verifications are done once per lazy repair round, PoR verification takes 176.2% of the time\n",
"There are 438.0 PoR verification rounds in a year accumulating 610018.8 GB of storage\n"
2022-08-10 10:16:12 +02:00
]
2022-09-21 15:05:59 +02:00
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1080x576 with 1 Axes>"
],
"image/png": "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
},
"metadata": {
"needs_background": "light"
}
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1080x576 with 0 Axes>"
]
},
"metadata": {}
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1080x576 with 1 Axes>"
],
"image/png": "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
},
"metadata": {
"needs_background": "light"
}
2022-08-10 10:16:12 +02:00
}
],
"source": [
"import numpy as np\n",
"import random as random\n",
"import matplotlib.pyplot as plt\n",
"\n",
"plt.rcParams['figure.figsize'] = [15, 8]\n",
"\n",
"\n",
"#@markdown #Network parameters. \n",
"#@markdown These parameters give the characteristic of the network and we (Codex) have no control over them.\n",
"\n",
"#@markdown Number of nodes in the network\n",
"NetworkSize = 15400 #@param {type:\"slider\", min:100, max:20000, step:100}\n",
"#@markdown Average storage size per node (in GB)\n",
"NodeCapacity = 1200 #@param {type:\"slider\", min:100, max:10000, step:100}\n",
"#@markdown Number of files in the system\n",
"NumberOfFiles = 1206000 #@param {type:\"slider\", min:1000, max:10000000, step:1000}\n",
"#@markdown File size (in KB)\n",
"FileSize = 10000000 #@param {type:\"slider\", min:100, max:10000000, step:100}\n",
"#@markdown Overall network MTBF (in hours)\n",
2022-09-21 15:05:59 +02:00
"MTBF = 1 #@param {type:\"slider\", min:1, max:100, step:1}\n",
2022-08-10 10:16:12 +02:00
"#@markdown Percentage of data a malicious node discards or refuses/avoids to store\n",
"CheatRatio = 5 #@param {type:\"slider\", min:5, max:95, step:5}\n",
"#@markdown Predefined Scenario (Set to 1 to overwrite the above parameters with the values from the Storj network)\n",
"Scenario = 0 #@param {type:\"slider\", min:0, max:1, step:1}\n",
"\n",
"#@markdown ----------------------------------------------------\n",
"#@markdown ----------------------------------------------------\n",
"#@markdown ----------------------------------------------------\n",
"\n",
"\n",
"#@markdown #Codex parameters\n",
"#@markdown The Codex team can tune the following parametersto potimize the system\n",
"\n",
"#@markdown Erasure Coding parameter K\n",
"ECK = 60 #@param {type:\"slider\", min:1, max:100, step:1}\n",
"#@markdown Erasure Coding parameter M\n",
"ECM = 40 #@param {type:\"slider\", min:1, max:100, step:1}\n",
"#@markdown Lazy repair parameter L (start repair after L erasures)\n",
"ECL = 20 #@param {type:\"slider\", min:1, max:100, step:1}\n",
"#@markdown Number of PoR sectors (PoR Parameter S)\n",
2022-09-21 15:05:59 +02:00
"PoRS = 1000 #@param {type:\"slider\", min:10, max:1000, step:10}\n",
2022-08-10 10:16:12 +02:00
"#@markdown PoR block agregation cost (in miliseconds)\n",
"AgregationCost = 1 #@param {type:\"slider\", min:1, max:100, step:1}\n",
"#@markdown Durability guarantee (three 9s (99.9%) to nine 9s (99.9999999%))\n",
"Durability = 9 #@param {type:\"slider\", min:3, max:9, step:3}\n",
"\n",
"\n",
"# #@markdown Number of EC blocks to verify among K+M nodes\n",
"#HorizontalVerification = 40 #@param {type:\"slider\", min:1, max:100, step:1}\n",
"##@markdown Percentage of PoR blocks to verify inside an EC block\n",
"#VerticalVerification = 0.2 #@param {type:\"slider\", min:0.1, max:1, step:0.1}\n",
"\n",
"\n",
"if Scenario == 1:\n",
" print(\"\\n***This is the Storj scenario***\\n\")\n",
" NetworkSize = 15400\n",
" NodeCapacity = 1200\n",
" NumberOfFiles = 1200000\n",
" FileSize = 10000000\n",
"\n",
"print(\"\\n *** Network Parameters *** \\n\")\n",
"print(\"The network has %d nodes\" % NetworkSize)\n",
"print(\"The average node capacity is %d GBs\" % NodeCapacity)\n",
"print(\"The network has %d files\" % NumberOfFiles)\n",
"print(\"The average file size in the network is %d MBs\" % (FileSize/1024))\n",
"print(\"The estimated mean time between failures of the network is %d hours\" % MTBF)\n",
"print(\"Malicious nodes cheat the system by NOT storing %d%% of the data they should store\" % CheatRatio)\n",
"\n",
"\n",
"print(\"\\n *** Codex Parameters *** \\n\")\n",
"print(\"The erasure coding parameter K is %d\" % ECK)\n",
"print(\"The erasure coding parameter M is %d\" % ECM)\n",
"print(\"The lazy repair parameter L is %d\" % ECL)\n",
"print(\"The Proof of Retrievability number of sectors per block is %d\" % PoRS)\n",
"print(\"The PoR agregation cost is %d ms per PoR block\" % AgregationCost)\n",
"print(\"Durability in number of nines: %d\" % Durability)\n",
"\n",
"ECblockSize = FileSize/ECK\n",
"PoRblockSize = 31*PoRS/1024\n",
"TotalECBlocks = NumberOfFiles*(ECK+ECM)\n",
"ECBlocksPerNode = TotalECBlocks/NetworkSize\n",
"NbPoRinEC = ECblockSize/PoRblockSize\n",
2022-12-01 11:55:50 +01:00
"TotalUsedCapacityTB = int(NumberOfFiles*FileSize)/int(1024*1024*1024)\n",
2022-09-21 15:05:59 +02:00
"TotalNetworkCapacity = NetworkSize*NodeCapacity/1024\n",
2022-08-10 10:16:12 +02:00
"\n",
"print(\"\\n *** Dataset and block structures *** \\n\")\n",
"print(\"There are %d files of size %d KB (%2.1f MB)\" % (NumberOfFiles, FileSize, FileSize/1024))\n",
2022-12-01 11:55:50 +01:00
"print(\"The total storage used in the network is %2.1f TB and there is %2.1f TB of available storage for a total of %2.1f TB\" % (TotalUsedCapacityTB, TotalNetworkCapacity-TotalUsedCapacityTB, TotalNetworkCapacity))\n",
2022-08-10 10:16:12 +02:00
"print(\"There will be %d EC blocks of size %2.1f MBs per file\" % (ECK+ECM, ECblockSize/1024))\n",
"print(\"There is a total of %d EC blocks in the network\" % TotalECBlocks)\n",
"print(\"There is an average of %2.1f EC blocks per node (assuming an homogeneous distribution)\" % ECBlocksPerNode)\n",
"print(\"Each EC block has %2.1f PoR blocks of size %2.1f KB\" % (NbPoRinEC, PoRblockSize))\n",
"\n",
"\n",
"print(\"\\n *** Durability guarantees and verification frequency *** \\n\")\n",
"GuaranteeDurability = {3:99.90, 6: 99.99990, 9: 99.99999990}\n",
"ExpectedGuarantee = GuaranteeDurability[Durability]\n",
"\n",
2022-09-21 15:05:59 +02:00
"\n",
"\n",
"hx = []\n",
"HorizontalProb = []\n",
"HorizontalResults = {3:0, 6:0, 9:0}\n",
2022-08-10 10:16:12 +02:00
"for NbOfHVerif in range(ECK):\n",
" prob = (1-(((ECK-1)/100)**NbOfHVerif))*100\n",
2022-09-21 15:05:59 +02:00
" hx.append(NbOfHVerif)\n",
" HorizontalProb.append(prob)\n",
" if prob > GuaranteeDurability[3] and HorizontalResults[3] == 0:\n",
" HorizontalResults[3] = NbOfHVerif\n",
" if prob > GuaranteeDurability[6] and HorizontalResults[6] == 0:\n",
" HorizontalResults[6] = NbOfHVerif\n",
" if prob > GuaranteeDurability[9] and HorizontalResults[9] == 0:\n",
" HorizontalResults[9] = NbOfHVerif\n",
"\n",
"HorizontalVerification = HorizontalResults[9] \n",
"print(\"We need %d horizontal verifications to have %12.12f%% guarantee\" % (HorizontalResults[3], GuaranteeDurability[3]))\n",
"print(\"We need %d horizontal verifications to have %12.12f%% guarantee\" % (HorizontalResults[6], GuaranteeDurability[6]))\n",
"print(\"We need %d horizontal verifications to have %12.12f%% guarantee\" % (HorizontalResults[9], GuaranteeDurability[9]))\n",
" \n",
"VerticalProb = []\n",
"VerticalResults = {3:0, 6:0, 9:0}\n",
2022-08-10 10:16:12 +02:00
"for NbOfVVerif in range(1, int(NbPoRinEC)):\n",
" prob = (1-((1-(CheatRatio/100))**NbOfVVerif))*100\n",
2022-09-21 15:05:59 +02:00
" if prob > GuaranteeDurability[3] and VerticalResults[3] == 0:\n",
" VerticalResults[3] = NbOfVVerif*100/NbPoRinEC\n",
" if prob > GuaranteeDurability[6] and VerticalResults[6] == 0:\n",
" VerticalResults[6] = NbOfVVerif*100/NbPoRinEC\n",
" if prob > GuaranteeDurability[9] and VerticalResults[9] == 0:\n",
" VerticalResults[9] = NbOfVVerif*100/NbPoRinEC\n",
" VerticalProb.append(prob)\n",
"\n",
"print(\"For Cheat Ratio : %d\" % CheatRatio)\n",
"VerticalVerification = VerticalResults[9]\n",
"print(\"We need %2.1f%% vertical verifications to have %12.12f%% guarantee\" % (VerticalResults[3], GuaranteeDurability[3]))\n",
"print(\"We need %2.1f%% vertical verifications to have %12.12f%% guarantee\" % (VerticalResults[6], GuaranteeDurability[6]))\n",
"print(\"We need %2.1f%% vertical verifications to have %12.12f%% guarantee\" % (VerticalResults[9], GuaranteeDurability[9]))\n",
2022-08-10 10:16:12 +02:00
"\n",
2022-09-21 15:05:59 +02:00
"\n",
"print(\"\\nGuarantee of data durability is %9.9f\" % ExpectedGuarantee)\n",
2022-08-10 10:16:12 +02:00
"print(\"The PoR horizontal verification factor is %2.1f\" % HorizontalVerification)\n",
2022-09-21 15:05:59 +02:00
"print(\"The PoR vertical verification factor is %2.1f%%\" % VerticalVerification)\n",
2022-08-10 10:16:12 +02:00
"\n",
"\n",
2022-12-01 11:55:50 +01:00
"TotalPoRStorageMB = NumberOfFiles*HorizontalVerification*PoRblockSize/1024\n",
2022-12-01 11:53:56 +01:00
"NodeAgregationTime = NbPoRinEC*VerticalVerification/100*ECBlocksPerNode*(HorizontalVerification/(ECK+ECM))*AgregationCost/(1000*60)\n",
2022-08-10 10:16:12 +02:00
"PoRPerYear = 365*24/(ECL*MTBF)\n",
"\n",
"\n",
"print(\"\\n *** PoR Storage and Time Requirements *** \\n\")\n",
2022-12-01 11:55:50 +01:00
"print(\"The total storage required for PoR proofs is %2.1f MB to check a total of %2.1fTB of data each round (%2.6f%%)\" % (TotalPoRStorageMB, TotalUsedCapacityTB, TotalPoRStorageMB/TotalUsedCapacityTB/1024/1024*100))\n",
2022-09-21 15:05:59 +02:00
"print(\"To verify %d EC blocks and %2.1f%% PoR blocks per file in the system:\" % (HorizontalVerification, VerticalVerification))\n",
2022-08-10 10:16:12 +02:00
"print(\"Each node will spend %2.1f minutes (%2.1f hours) agregating PoR proofs\" % (NodeAgregationTime, NodeAgregationTime/60))\n",
"print(\"It will take the system %d hours (%2.1f days) to accidentally lose M nodes\" % (MTBF*ECM, MTBF*ECM/24))\n",
"print(\"Lazy repair should be triggered after %d hours (%2.1f days)\" % (MTBF*ECL, MTBF*ECL/24))\n",
"print(\"Assuming PoR verifications are done once per lazy repair round, PoR verification takes %2.1f%% of the time\" % ((NodeAgregationTime*100)/(MTBF*ECL*60)))\n",
2022-12-01 11:55:50 +01:00
"print(\"There are %2.1f PoR verification rounds in a year accumulating %2.1f GB of storage\" % (PoRPerYear, PoRPerYear*TotalPoRStorageMB/1024))\n",
2022-09-21 15:05:59 +02:00
"\n",
"color = [\"red\", \"orange\", \"green\", \"blue\"]\n",
"storVector = []\n",
"aggVector = []\n",
"HorVer = [HorizontalResults[3], HorizontalResults[6], HorizontalResults[9]]\n",
"VerVec = [VerticalResults[3], VerticalResults[6], VerticalResults[9]]\n",
"for i in range(len(HorizontalResults)):\n",
" vx = range(64,1024,4)\n",
" agregationVector = []\n",
" storageVector = []\n",
" for PoRS in range(64,1024,4):\n",
" PoRblockSize = 31*PoRS/1024\n",
" NbPoRinEC = ECblockSize/PoRblockSize\n",
2022-12-01 11:55:50 +01:00
" TotalPoRStorageMB = NumberOfFiles*HorVer[i]*PoRblockSize/(1024*1024)\n",
2022-12-01 11:53:56 +01:00
" NodeAgregationTime = NbPoRinEC*VerVec[i]/100*ECBlocksPerNode*(HorizontalVerification/(ECK+ECM))*AgregationCost/(1000*60*60)\n",
2022-09-21 15:05:59 +02:00
" PoRPerYear = 365*24/(ECL*MTBF)\n",
2022-12-01 11:55:50 +01:00
" storageVector.append(TotalPoRStorageMB)\n",
2022-09-21 15:05:59 +02:00
" agregationVector.append(NodeAgregationTime)\n",
" storVector.append(storageVector)\n",
" aggVector.append(agregationVector)\n",
" \n",
"\n",
"fig, ax = plt.subplots()\n",
"plt.grid(axis='x', color='0.9')\n",
"plt.grid(axis='y', color='0.9')\n",
"plt.title(\"PoR Storage Consumption\")\n",
"plt.xlabel(\"Number of PoR sectors per block\")\n",
"plt.ylabel(\"PoR storage (GB)\")\n",
"for i in range(len(HorizontalResults)):\n",
" ax.plot(vx, storVector[i], label = HorVer[i], color = color[i])\n",
"#plt.yscale('log')\n",
"ax.legend()\n",
"plt.show()\n",
"plt.clf()\n",
"\n",
"fig, ax = plt.subplots()\n",
"plt.grid(axis='x', color='0.9')\n",
"plt.grid(axis='y', color='0.9')\n",
"plt.title(\"PoR Aggregation time for one complete check\")\n",
"plt.xlabel(\"Number of PoR sectors per block\")\n",
"plt.ylabel(\"PoR agregation time (Hours)\")\n",
"for i in range(len(HorizontalResults)):\n",
" ax.plot(vx, aggVector[i], label = VerVec[i], color = color[i])\n",
"ax.legend()\n",
"plt.show()\n",
"#print(storageVector)\n"
2022-08-10 10:16:12 +02:00
]
}
]
}
