# Data Integrity Preservation Schemes in Smart Healthcare Systems That Use Fog Computing Distribution

^{1}

^{2}

^{*}

## Abstract

**:**

## 1. Introduction

## 2. Literature Review

#### 2.1. Security and Privacy Issues in Fog Computing

#### 2.2. Fog Computing in Healthcare

#### 2.3. Data Integrity in Fog Computing

## 3. Proposed Scheme

#### 3.1. Scheme Abbreviation Part

#### 3.2. First Model

#### The Proposed Damage Assessment Algorithms

- Algorithm 1: building local graphs for private distributed fog computing:

Algorithm 1 Building Local Graphs. |

1: Create a new Hash-table H and Initialize to null 2: Create a new Graph Representation $G=($T${}_{n}$, $E)$ and Initialize to null 3: When T${}_{i}$ is committed in the local DB then 4: for each operation O ∈ T${}_{i}$ do5: if O is ${w}_{i}$$(A,v1,v2)$ then6: add a pair $(A,$ T${}_{i}$ $ID)$ to H 7: add Ti as a new vertex to G if it does not exist 8: else if O is ${r}_{i}$ $(A,v)$ then9: if A∈ H then10: add T${}_{i}$ as a new vertex to G if it does not exist 11: acquire the parents T${}_{j}$ ID from H 12: add edge from T${}_{j}$ to T${}_{i}$ 13: else if A ∈ foreign fog node then14: call global graph algorithm (Algorithm 2) 15: end if16: else if O is ${c}_{i}$ then17: end if18: end for |

_{1}(A, 45) r

_{1}(B, 34) w

_{1}(C, 29, 80) w

_{1}(G, 23, 18) r

_{2}(B, 34) c

_{1}w

_{2}(A, 45, 48) w

_{2}(D, 12, 35) c

_{2}r

_{3}(G, 18) c

_{3}w

_{4}(A, 48, 69) w

_{4}(G, 18, 24) c

_{4}r

_{5}(D, 35) r

_{5}(A, 69) w

_{5}(D, 35, 98) c

_{5}r

_{6}(B, 34) w

_{6}(B, 34, 63) r

_{6}(D, 98) w

_{6}(D, 98, 24) r

_{6}(A, 69) w

_{6}(A, 69, 78) c

_{6}r

_{7}(D, 24) c

_{7}r

_{8}(C, 80)c

_{8}r

_{9}(fog

_{y}·T6·TV, 56) w

_{9}(C, 80, 93) c

_{9}r

_{10}(A, 78) r

_{10}(C, 93) w

_{10}(E, 39, 66)c

_{10}r

_{11}(E, 66) c

_{11}.

_{1}(K, 58) r

_{1}(fog

_{x}·T4·G, 24)w

_{1}(K, 58, 98)c

_{1}r

_{2}(M, 39) r

_{2}(K, 98)w

_{2}(M, 39, 59)c

_{2}r

_{3}(R, 43)c

_{3}r

_{4}(fog

_{x}·T5·D, 35) r

_{4}(M, 59) w

_{4}(N, 36, 84) c

_{4}r

_{5}(K, 98) w

_{5}(P, 43, 78)c

_{5}w

_{6}(V, 56) c

_{6}.

- Algorithm 2: building global graphs on the trusted fog node:

- T${}_{i}$, committed to the MSFN${}_{y}$ accesses data item A. The last transaction update for data item A was T${}_{j}$ on MSFN${}_{x}$.
- A copy of the graph updating that last transaction’s data item A is sent to the global graph on the trusted fog node. The global graph includes all preceding vertices that could directly or indirectly affect T${}_{j}$.
- Transaction T${}_{i}$ is added as a new child of T${}_{j}$ to the global graph and an edge is drawn from transaction T${}_{j}$ to T${}_{i}$.
- Transaction T${}_{i}$ from MSFN${}_{y}$ continues updates to the global graph on the trusted fog node by copying and sending a copy of each subsequent transaction consigned locally at the MSFN${}_{y}$ (successor of T${}_{i}$). This copy updates and is sent frequently.

Algorithm 2 Building global graphs on the trusted fog node. |

1: Create a new Global Graph Representation G${}_{g}$ = (T${}_{n}$, E) on trusted fog node and Initialize to null 2: (When T${}_{i}$ ∈ fog${}_{x}$ reads data item A ∈ fog${}_{y}$) then 3: for each ${r}_{i}$ $(A,v)$ ∈ T${}_{i}$ do4: acquire all predecessors of T${}_{j}$ from G${}_{y}$ 5: add Ti as a new vertex to G${}_{g}$ if it does not exist 6: add edge from MSFN${}_{y}$.T${}_{j}$ to MSFN${}_{x}$.T${}_{i}$ 7: end for8: (When a new transaction T${}_{z}$ ∈ MSFN${}_{x}$ is committed where T${}_{z}$ is successor of T${}_{i}$) then 9: add Tz as a new vertex to G${}_{g}$ if it does not exist 10: add edge from T${}_{i}$ to T${}_{z}$ |

_{1}from MSFN${}_{y}$ is committed, it is added to both the global graph on the trusted fog node and the local MSFN${}_{y}$ graph.

- In the log records of MSFN${}_{y}$, T${}_{2}$ reads data item K from T${}_{1}$. T${}_{2}$ is added as a new vertex in the local MSFN${}_{y}$ graph.
- An edge is drawn from T${}_{1}$ to T${}_{2}$. The global graph is subsequently updated by adding T${}_{2}$.
- And so, it continues: T${}_{4}$ reads item M from T${}_{2}$ and T${}_{5}$ reads item K from T${}_{1}$. Hence, T${}_{4}$ and T${}_{5}$ are added as new vertices to the local MSFN${}_{y}$ graph. Edges are drawn from T${}_{2}$ to T${}_{4}$ and from T${}_{1}$ to T${}_{5}$. Then T${}_{4}$ and T${}_{5}$ are added to the global graph. The MSFN${}_{y}$ will continue sending updated copies of T${}_{1}$’s successor to the global graph upon commit operating at its local database. This copy, as indicated, is updated and sent frequently.

- Algorithm 3: damage assessment algorithms for private distributed fog computing:

Algorithm 3 Damage assessment algorithm for private distributed fog computing. |

1: Once S{MSFN${}_{ID}$.T${}_{M}$} is received from IDS 2: Classify S{MSFN${}_{ID}$.T${}_{M}$} to multi-set {S${}_{1}${MSFN${}_{1}$.T${}_{M}$}..S${}_{n}${MSFN${}_{n}$.T${}_{M}$}} 3: Send each subset S${}_{n}${MSFN${}_{n}$.T${}_{M}$} to the (MSFN${}_{n}$) 4: Send S{MSFN${}_{ID}$.T${}_{M}$} to the trust fog node. 5: For the trust fog node and each other MSFN${}_{n}$ that receive S or S${}_{n}$. 6: MDFS (G${}_{n}$, T${}_{M1}$) 7: Create a new affected-transactions list Aff-Lfog${}_{n}$ and Initialize to null 8: Create a new Stack tranS and Initialize to null 9: add T${}_{M1}$ to tranS 10: mark T${}_{M1}$ as visited 11: while tranS is not empty do12: T${}_{M1}$ = tranS.pop 13: add T${}_{M1}$ to Aff-Lfog${}_{n}$ 14: for each child T${}_{i}$ of T${}_{M1}$ in G${}_{n}$ do15: if T${}_{i}$ is not in then Aff-Lfog${}_{n}$16: add T${}_{i}$ to tranS 17: mark T${}_{i}$ as visited and add it to Aff-Lfog${}_{n}$ 18: end if19: end for20: end while |

#### 3.3. Second Model

- Algorithm 4: building local graphs for public distributed fog nodes:

Algorithm 4 Building local graphs for public distributed fog computing. |

1: Create a new Hash-table H and Initialize to null 2: Create a new Graph Representation $G=($T${}_{n}$, $E)$ and Initialize to null 3: When T${}_{i}$ is committed in the local DB then 4: for each operation O ∈ T${}_{i}$ do5: if O is ${w}_{i}$ $(A,v1,v2)$ then6: add a pair $(A,$ T${}_{i}$ $ID)$ to H 7: add T${}_{i}$ as a new vertex to G if it does not exist 8: else if O is ${r}_{i}$ $(A,v)$ && A ∈ H then9: add T${}_{i}$ as a new vertex to G if it does not exist 10: acquire the parents T${}_{j}$ ID from H 11: add edge from T${}_{j}$ to T${}_{i}$ 12: else if T${}_{k}$ ∈ foreign fog node fog${}_{y}$ reads data item A that updated by T${}_{i}$ then13: add fog${}_{y}$.T${}_{k}$ as a new vertex to G if it does not exist 14: add edge from T${}_{i}$ to fog${}_{y}$.T${}_{k}$ 15: end if16: end for |

- Algorithm 5: damage assessment algorithms for public distributed fog nodes:

Algorithm 5 Damage assessment algorithm for public distributed fog nodes. |

1: Once S{fog${}_{ID}$.T${}_{M}$} is received from IDS 2: Assort S{fog${}_{ID}$.T${}_{M}$} to multi-set S${}_{1}$ … S${}_{n}$ 3: Send S${}_{x}${fog${}_{x}$.T${}_{M}$} to the (fog${}_{x}$) 4: For each fog${}_{x}$ that receive S${}_{x}$ 5: MDFS (G${}_{n}$, T${}_{M1}$) 6: Establish a new list for affected transactions (Aff-Lfog${}_{x}$) 7: Establish a new Stack ${S}_{T}$ 8: add T${}_{M1}$ to ${S}_{T}$ 9: mark T${}_{M1}$ as visited 10: while ${S}_{T}$ is not empty do11: T${}_{M1}$ = ${S}_{T}$.pop 12: add T${}_{M1}$ to Aff-Lfog${}_{x}$ 13: for each child T${}_{i}$ of T${}_{M1}$ in G${}_{n}$ do14: if T${}_{i}$ ∉ Aff-Lfog${}_{x}$ then15: add T${}_{i}$ to ${S}_{T}$ 16: mark T${}_{i}$ as visited 17: add T${}_{i}$ to Aff-Lfog${}_{x}$ 18: if T${}_{i}$ is foreign transaction ∈ fog${}_{y}$ then19: add T${}_{i}$ to sub-list Aff-Lfog${}_{x,y}$ 20: end if21: end if22: end for23: end while24: Send Aff-Lfog${}_{x,y}$ to fog${}_{y}$ to do further detection |

## 4. Implementation and Evaluation

#### 4.1. Setup

#### 4.2. Data-Set

#### 4.2.1. Log Files

- r${}_{2}$(345,669): is reading operation where r${}_{transaction\_number}$ (data item, value)
- w${}_{2}$(345,669,621): is writing operation where w${}_{transaction\_number}$ (data item, old value, new value)
- c${}_{2}$: The transaction 2 has been committed which means it is successfully completed.

#### 4.2.2. Graphs

#### 4.3. Experiments and Evaluation

#### 4.3.1. The Impact of the Different Sets of Affected Transactions on Various Fog Nodes Number on the First Model

#### 4.3.2. The Impact of Different Number of Transactions on Various Number of Fog Nodes on the First Model

#### 4.3.3. The Impact of the Different Sets of Affected Transactions on Various Fog Nodes Number on the Second Model

#### 4.3.4. The Impact of Different Number of Transactions on Various Number of Fog Nodes on the Second Model

#### 4.3.5. Overall Comparison between the Two Models

#### 4.3.6. Resource Requirement Cost

## 5. Conclusions

## Author Contributions

## Funding

## Conflicts of Interest

## Appendix A. Figures

Figure | Section | Description |
---|---|---|

Figure A1 | Section 3.2 | Described Local Dependency Graphs for MSFN${}_{y}$. |

Figure A2, Figure A3 and Figure A4 | Section 4.3.1 | The impact of the different sets of affected transactions on various fog nodes number on the first model. |

Figure A5, Figure A6 and Figure A7 | Section 4.3.2 | The impact of different number of transactions on various number of fog nodes on the first model. |

Figure A8, Figure A9 and Figure A10 | Section 4.3.3 | The impact of different number of transactions on various number of fog nodes on the second model. |

Figure A11, Figure A12 and Figure A13 | Section 4.3.4 | The impact of different number of transactions on various number of fog nodes on the second model |

## References

- Alazeb, A.; Panda, B. Ensuring Data Integrity in Fog Computing Based Health-Care Systems. In Proceedings of the International Conference on Security, Privacy and Anonymity in Computation, Communication and Storage, Atlanta, GA, USA, 14–17 July 2019; Springer: Atlanta, GA, USA, 2019. [Google Scholar] [CrossRef]
- Sanaa, K.; Haraty, R.; Masud, M. Tracking and Repairing Damaged Healthcare Databases Using the Matrix. Int. J. Distrib. Sens. Netw.
**2015**, 11. [Google Scholar] [CrossRef] - Dos Anjos, J.; Gross, J.L.; Matteussi, K.J.; González, G.V.; Leithardt, V.R.; Geyer, C.F. An Algorithm to Minimize Energy Consumption and Elapsed Time for IoT Workloads in a Hybrid Architecture. Sensors
**2021**, 21, 2914. [Google Scholar] [CrossRef] [PubMed] - Panda, B.; Kazi Asharful, H. Extended data dependency approach: A robust way of rebuilding database. In Proceedings of the 2002 ACM Symposium on Applied Computing, Madrid, Spain, 10–14 March 2002; pp. 446–452. [Google Scholar] [CrossRef]
- Mukherjee, M.; Matam, R.; Shu, L.; Maglaras, L.; Ferrag, M.A.; Choudhury, N.; Kumar, V. Security and Privacy in Fog Computing: Challenges. IEEE Access
**2017**, 5, 19293–19304. [Google Scholar] [CrossRef] - Okay, F.; Ozdemir, S. A secure data aggregation protocol for fog computing based smart grids. In Proceedings of the 2018 IEEE 12th International Conference on Compatibility, Power Electronics and Power Engineering (CPE-POWERENG 2018), Doha, Qatar, 10–12 April 2018. [Google Scholar] [CrossRef]
- Khan, S.; Parkinson, S.; Qin, Y. Fog computing security: A review of current applications and security solutions. J. Cloud Comput.
**2017**, 6, 1–22. [Google Scholar] [CrossRef] - Lin, J.; Yu, W.; Zhang, N.; Yang, X.; Zhang, H.; Zhao, W. A survey on internet of things: Architecture, enabling technologies, security and privacy, and applications. IEEE Internet Things J.
**2017**, 4, 1125–1142. [Google Scholar] [CrossRef] - Wu, D.; Ansari, N. A Cooperative Computing Strategy for Blockchain-secured Fog Computing. IEEE Internet Things J.
**2020**, 7, 6603–6609. [Google Scholar] [CrossRef] - Zhu, L.; Li, M.; Zhang, Z.; Xu, C.; Zhang, R.; Du, X.; Nadra, G. Privacy-Preserving Authentication and Data Aggregation for Fog-Based Smart Grid. IEEE Commun. Mag.
**2019**, 57, 80–85. [Google Scholar] [CrossRef] - Lyu, L.; Nandakumar, K.; Rubinstein, B.; Jin, J.; Bedo, J.; Palaniswami, M. PPFA: Privacy preserving fog-enabled aggregation in smart grid. IEEE Trans. Ind. Inform.
**2018**, 14, 3733–3744. [Google Scholar] [CrossRef] - Lu, R.; Heung, K.; Lashkari, A.H.; Ghorbani, A.A. A lightweight privacy-preserving data aggregation scheme for fog computing-enhanced IoT. IEEE Access
**2017**, 5, 3302–3312. [Google Scholar] [CrossRef] - Aazam, M.; Zeadally, S.; Harras, K. Deploying fog computing in industrial internet of things and industry 4.0. IEEE Trans. Ind. Inform.
**2018**, 14, 4674–4682. [Google Scholar] [CrossRef] - Alazeb, A.; Panda, B. Maintaining Data Integrity in Fog Computing Based Critical Infrastructure Systems. In Proceedings of the 2019 International Conference on Computational Science and Computational Intelligence, Las Vegas, NV, USA, 5–7 December 2019. [Google Scholar] [CrossRef]
- OpenFog Consortium Architecture Working Group. OpenFog Reference Architecture for Fog Computing; Budapest University of Technology and Economics: Budapest, Hungary, 2017. [Google Scholar]
- Silva, L.A.; Leithardt, V.R.Q.; Rolim, C.O.; González, G.V.; Geyer, C.F.; Silva, J.S. PRISER: Managing notification in multiples devices with data privacy support. Sensors
**2019**, 19, 3098. [Google Scholar] [CrossRef] [Green Version] - Azimi, I.; Anzanpour, A.; Rahmani, A.; Pahikkala, T.; Levorato, M.; Liljeberg, P.; Dutt, N. Hich: Hierarchical fog-assisted computing architecture for healthcare iot. ACM Trans. Embed. Comput. Syst.
**2017**, 16, 1–20. [Google Scholar] [CrossRef] - Akrivopoulos, O.; Chatzigiannakis, I.; Tselios, C.; Antoniou, A. On the deployment of healthcare applications over fog computing infrastructure. In Proceedings of the 2017 IEEE 41st Annual Computer Software and Applications Conference (COMPSAC), Turin, Italy, 4–8 July 2017. [Google Scholar] [CrossRef] [Green Version]
- Dastjerdi, A.; Buyya, R. Fog Computing: Helping the Internet of things Realize Its Potential. Computer
**2016**, 49, 112–116. [Google Scholar] [CrossRef] - Vora, J.; Tanwar, S.; Tyagi, S.; Kumar, N.; Rodrigues, J. FAAL: Fog computing-based patient monitoring system for ambient assisted living. In Proceedings of the 2017 IEEE 19th International Conference on e-Health Networking, Applications and Services (Healthcom), Dalian, China, 12–15 October 2017. [Google Scholar] [CrossRef]
- Vijayakumar, V.; Malathi, D.; Subramaniyaswamy, V.; Saravanan, P.; Logesh, R. Fog computing-based intelligent healthcare system for the detection and prevention of mosquito-borne diseases. Comput. Hum. Behav.
**2019**, 100, 275–285. [Google Scholar] [CrossRef] - Naranjo, P.; Pooranian, Z.; Shojafar, M.; Conti, M.; Buyya, R. FOCAN: A Fog-supported smart city network architecture for management of applications in the Internet of Everything environments. J. Parallel Distrib. Comput.
**2019**, 132, 274–283. [Google Scholar] [CrossRef] [Green Version] - Tang, B.; Chen, Z.; Hefferman, G.; Wei, T.; He, H.; Yang, Q. A hierarchical distributed fog computing architecture for big data analysis in smart cities. Proc. Ase Bigdata Soc.
**2015**, 2015, 1–6. [Google Scholar] [CrossRef] - Amaxilatis, D.; Chatzigiannakis, I.; Tselios, C.; Tsironis, N.; Niakas, N.; Papadogeorgos, S. A smart water metering deployment based on the fog computing paradigm. Appl. Sci.
**2020**, 10, 1965. [Google Scholar] [CrossRef] [Green Version] - Froiz, M.; Fern, T.; Fraga-Lamas, P.; Castedo, L. Design, implementation and practical evaluation of an IoT home automation system for fog computing applications based on MQTT and ZigBee-WiFi sensor nodes. Sensors
**2018**, 8, 2660. [Google Scholar] [CrossRef] [Green Version] - Wang, P.; Liu, S.; Ye, F.; Chen, X. A fog-based architecture and programming model for iot applications in the smart grid. arXiv
**2018**, arXiv:1804.01239. [Google Scholar] - Zuo, Y.; Panda, B. Distributed database damage assessment paradigm. Inf. Manag. Comput. Secur.
**2006**, 14, 116–139. [Google Scholar] [CrossRef] - Peng, L.; Yu, M. Damage assessment and repair in attack resilient distributed database systems. Comput. Stand. Interfaces
**2011**, 33, 96–107. [Google Scholar] [CrossRef] - Paul, A.; Sushil, J.; Peng, L. Recovery from malicious transactions. IEEE Trans. Knowl. Data Eng.
**2002**, 14, 1167–1185. [Google Scholar] [CrossRef] - Anindya, C.; Arun K, M.; Shamik, S. A column dependency-based approach for static and dynamic recovery of databases from malicious transactions. Int. J. Inf. Secur.
**2002**, 9, 51–67. [Google Scholar] [CrossRef] - Rao, U.; Patel, D. Incorporation of application specific information for recovery in database from malicious transactions. Inf. Secur. J. Glob. Perspect.
**2013**, 22, 35–45. [Google Scholar] [CrossRef] - Haraty, R.; Sanaa, K.; Zekri, A. Transaction dependency based approach for database damage assessment using a matrix. Int. J. Semant. Web Inf. Syst.
**2017**, 13, 74–86. [Google Scholar] [CrossRef] - Xie, M.; Zhu, H.; Feng, Y.; Hu, G. Tracking and repairing damaged databases using before image table. In Proceedings of the 2008 Japan-China Joint Workshop on Frontier of Computer Science and Technology, Nagasahi, Japan, 27–28 December 2007; pp. 36–41. [Google Scholar] [CrossRef]
- Panda, B.; Alazeb, A. Securing Database Integrity in Intelligent Government Systems that Employ Fog Computing Technology. In Proceedings of the 2020 International Conference on Computing and Data Science (CDS), Stanford, CA, USA, 1–2 August 2020; IEEE: New York, NY, USA, 2020. ISBN 978-1-7281-7106-7. [Google Scholar] [CrossRef]
- Chang, C.; Narayana Srirama, S.; Buyya, R. Indie Fog: An Efficient Fog-Computing Infrastructure for the Internet of things. Computer
**2017**, 50, 92–98. [Google Scholar] [CrossRef] - Kontopoulos, S.; Drakopoulos, G. A space efficient scheme for persistent graph representation. In Proceedings of the 2014 IEEE 26th International Conference on Tools with Artificial Intelligence, Limassol, Cyprus, 10–12 November 2014; pp. 299–303. [Google Scholar] [CrossRef]
- Cormen, T.; Leiserson, C.; Rivest, R.; Stein, C. Introduction to Algorithms, 3rd ed.; MIT Press: Cambridge, MA, USA, 2009. [Google Scholar]

**Figure 10.**Comparison between having global graph on trusted fog node and not on a set of less than five affected transactions.

**Figure 11.**Comparison between having global graph on trusted fog node and not on set of 10 to 15 affected transactions.

**Figure 12.**Comparison between having global graph on trusted fog node and not on a set of 30–35 affected Transactions.

Type of Dependency | Space Requirement | Auxiliary Structure | Methodology | Drawback | |
---|---|---|---|---|---|

[27] | Transaction | NA | NA | Scan the entire log files. | Time consuming. |

[2,32] | Data | Large Space | Matrix | Scan only the matrix. | Require a lot of space. |

[33] | Data | Large Space | Tables | Refer to tables | Require space and Do unnecessary work. |

[1] | Data | NA | NA | Scan the affected log files. | Continuous communication between all affected fog nodes. |

[14] | Data | NA | NA | Scan the affected log files. | Continuous communication between all affected fog nodes. |

The Proposed Scheme | Transaction | Small Space | Graphs | Scan only the affected graphs |

Notation | Definition |
---|---|

FN${}_{pub}$ | Public fog data service node on the system. |

MSFN | The main medical service fog node. |

S{fog${}_{ID}$.T${}_{M}$} | The detected malicious transactions set done by IDS. |

G(T${}_{n}$, E) | Graph representation where T${}_{n}$ indicates the number of transactions in the node and E indicates the number of edges |

Aff-Lfog${}_{n}$ | List of all affected transactions that have been identified by the proposed mechanism. |

T${}_{No.}$ | Transaction which is a single unit of logic in database and contains of multiple operations |

A, X, or W | Data item which is the smallest element in the transaction. |

${w}_{i}(A,{v}_{1},{v}_{2})$ | The write operation of the transaction T${}_{i}$; ${v}_{1}$ is the old value of the data item A, and ${v}_{2}$ is the new value of data item A after it is updated. |

${r}_{i}(A,v)$ | The read operation of transaction T${}_{i}$ where A is the data item and v is the current value of A. |

${c}_{i}$ | The transaction T${}_{i}$ has been successfully committed to the database. |

O | Operation ∈ T${}_{i}$ (write, read, or committed). |

$\Theta (V+E)$ | $\Theta $ is Big-O notation, which symbolizes upper bound of the space or running time. V is the set of vertices which in our models is the number of transactions in the log file T, and E is the set of edges which are the dependencies between two transactions. |

Data Items | C | G | A | D |

Last updated T | T${}_{1}$ | T${}_{4}$ | T${}_{4}$ | T${}_{5}$ |

Data Items | C | G | A | D | B | E |

Last updated T | T${}_{9}$ | T${}_{4}$ | T${}_{6}$ | T${}_{6}$ | T${}_{6}$ | T${}_{10}$ |

No. of Fog Nodes | Storage Requirement In Bytes | |||||
---|---|---|---|---|---|---|

100 Transactions | 500 Transactions | 1000 Transactions | ||||

Global Graph | All Local Log Files | Global Graph | All Local Log Files | Global Graph | All Local Log Files | |

5 | 3857 | 29,535 | 38,423 | 177,345 | 90,978 | 370,110 |

10 | 7351 | 65,200 | 79,425 | 400,750 | 182,027 | 842,220 |

15 | 12,403 | 96,600 | 121,354 | 603,750 | 283,796 | 1,302,885 |

20 | 16,725 | 125,800 | 166,822 | 806,580 | 386,372 | 1,738,640 |

Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations. |

© 2021 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Alazeb, A.; Panda, B.; Almakdi, S.; Alshehri, M.
Data Integrity Preservation Schemes in Smart Healthcare Systems That Use Fog Computing Distribution. *Electronics* **2021**, *10*, 1314.
https://doi.org/10.3390/electronics10111314

**AMA Style**

Alazeb A, Panda B, Almakdi S, Alshehri M.
Data Integrity Preservation Schemes in Smart Healthcare Systems That Use Fog Computing Distribution. *Electronics*. 2021; 10(11):1314.
https://doi.org/10.3390/electronics10111314

**Chicago/Turabian Style**

Alazeb, Abdulwahab, Brajendra Panda, Sultan Almakdi, and Mohammed Alshehri.
2021. "Data Integrity Preservation Schemes in Smart Healthcare Systems That Use Fog Computing Distribution" *Electronics* 10, no. 11: 1314.
https://doi.org/10.3390/electronics10111314