# VidBlock: A Web3.0-Enabled Decentralized Blockchain Architecture for Live Video Streaming
## 4 Experiment and Evaluation
### Performance Test
#### 4.2.2 Memory Performance Evaluation for VidBlock Under Concurrent Requests  
The evaluation of the VidBlock application in a P2P live streaming environment, as shown in Figure 8, centered on analyzing memory overhead across varying numbers of concurrent connections. The primary objective was to determine the scalability of the application as the load increased and to assess whether a higher number of P2P connections would lead to a proportional increase in memory usage. Three scenarios were tested: 5, 100, and 250 concurrent connection requests. Key memory metrics analyzed included the total proportional set size (PSS), total resident set size (RSS), native heap used and allocated, Dalvik heap used and allocated, and total private dirty memory. Understanding Memory Metrics [32; 33; 34]  
To contextualize the findings, it is essential to define the memory metrics used in this evaluation:  
* **PSS (proportional set size):** PSS represents the memory that is allocated exclusively to an application, as well as a proportional share of memory that the application shares with other processes. This metric is especially valuable in scenarios where memory is shared across multiple applications because it divides the memory of shared pages proportionally among all processes that use it. For instance, if a memory page is shared by two applications, each is attributed half of the memory size in their PSS. This makes PSS a critical indicator of an application's actual private memory footprint, as it accounts for both exclusive and shared memory usage. Monitoring PSS provides insight into how efficiently the application is managing memory in a multi-process environment, as higher PSS values indicate greater private memory consumption. * **RSS (resident set size):** RSS is the total amount of physical memory currently used by the application, encompassing both private memory and shared memory pages. Unlike PSS, RSS does not divide shared memory among processes; instead, it counts each shared page fully in the memory usage of every process that references it. This metric offers a comprehensive view of the application's overall memory demand on the system. Since RSS includes both private and shared pages, it is particularly useful for understanding the impact of an application on the system's physical memory resources. High RSS values suggest that the application is consuming a large amount of memory, which could affect the performance of other processes on the device if memory resources are constrained. * Native heap and Dalvik heap: Together, the Native heap and Dalvik heap metrics provide a detailed view of the memory consumption across the two primary runtime environments in Android, offering insights into the balance of native and managed memory usage within the application. Monitoring these metrics helps to identify any memory inefficiencies in both native and managed code components. * **The Native heap*
* represents memory allocated outside the Java virtual machine (JVM) by the application's native (C/C++) code. This memory is managed directly by the application and is not subject to garbage collection. Native heap usage is significant in applications that rely heavily on lower-level system functions, as it reflects the memory consumed by native code operations. In Android, managing native heap memory efficiently is crucial for performance, as memory leaks or excessive allocation can lead to increased memory pressure on the system. * **The Dalvik heap*
* (or managed heap) is the memory allocated within the JVM for objects and data managed by Android's garbage collector. Dalvik heap usage
reflects the memory footprint of code written in Java or Kotlin, which runs on the Android runtime (ART). Efficient Dalvik heap management is essential to minimize garbage collection overhead and to ensure smooth application performance, as excessive or fragmented allocation in the Dalvik heap can lead to frequent garbage collection cycles, causing noticeable performance degradation.