2022-08-10 10:16:12 +02:00
{
"cells": [
{
"cell_type": "markdown",
2022-12-01 11:57:35 +01:00
"metadata": {
"id": "IAw0wWuN-1Yh"
},
2022-08-10 10:16:12 +02:00
"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"
2022-12-01 11:57:35 +01:00
]
2022-08-10 10:16:12 +02:00
},
{
"cell_type": "code",
2022-12-01 11:57:35 +01:00
"execution_count": 1,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 1000
},
"id": "Y_CIsSJz_Nek",
"outputId": "7a352dbc-9ee6-4c3b-db37-79600fe8b1b7"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"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"
]
},
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"<Figure size 432x288 with 0 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/png": "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
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
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",
"#@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"
]
},
2022-09-21 15:05:59 +02:00
{
"cell_type": "markdown",
2022-12-01 11:57:35 +01:00
"metadata": {
"id": "7vid6VP3a_oM"
},
2022-09-21 15:05:59 +02:00
"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"
2022-12-01 11:57:35 +01:00
]
2022-09-21 15:05:59 +02:00
},
2022-08-10 10:16:12 +02:00
{
"cell_type": "markdown",
2022-12-01 11:57:35 +01:00
"metadata": {
"id": "Bw-GGBdX6tMm"
},
2022-08-10 10:16:12 +02:00
"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."
2022-12-01 11:57:35 +01:00
]
2022-08-10 10:16:12 +02:00
},
{
"cell_type": "code",
2022-12-01 11:57:35 +01:00
"execution_count": 2,
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": [
{
"name": "stdout",
2022-12-01 11:57:35 +01:00
"output_type": "stream",
2022-08-10 10:16:12 +02:00
"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-12-01 11:57:35 +01:00
"The total storage required for PoR proofs is 1426162.7 MB to check a total of 11231.8TB of data each round (0.012109%)\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",
2022-12-01 11:57:35 +01:00
"Each node will spend 21.1 minutes (0.4 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",
2022-12-01 11:57:35 +01:00
"Assuming PoR verifications are done once per lazy repair round, PoR verification takes 1.8% of the time\n",
2022-09-21 15:05:59 +02:00
"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
},
{
"data": {
2022-12-01 11:57:35 +01:00
"image/png": "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
2022-09-21 15:05:59 +02:00
"text/plain": [
"<Figure size 1080x576 with 1 Axes>"
2022-12-01 11:57:35 +01:00
]
2022-09-21 15:05:59 +02:00
},
"metadata": {
"needs_background": "light"
2022-12-01 11:57:35 +01:00
},
"output_type": "display_data"
2022-09-21 15:05:59 +02:00
},
{
"data": {
"text/plain": [
"<Figure size 1080x576 with 0 Axes>"
]
},
2022-12-01 11:57:35 +01:00
"metadata": {},
"output_type": "display_data"
2022-09-21 15:05:59 +02:00
},
{
"data": {
2022-12-01 11:57:35 +01:00
"image/png": "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
2022-09-21 15:05:59 +02:00
"text/plain": [
"<Figure size 1080x576 with 1 Axes>"
2022-12-01 11:57:35 +01:00
]
2022-09-21 15:05:59 +02:00
},
"metadata": {
"needs_background": "light"
2022-12-01 11:57:35 +01:00
},
"output_type": "display_data"
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
]
}
2022-12-01 11:57:35 +01:00
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3.9.15 64-bit",
"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.15"
},
"vscode": {
"interpreter": {
"hash": "a665b5d41d17b532ea9890333293a1b812fa0b73c9c25c950b3cedf1bebd0438"
}
}
},
"nbformat": 4,
"nbformat_minor": 0
}
