File size: 4,813 Bytes
8956b1e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | import matplotlib.pyplot as plt
import numpy as np
# Set a clean, academic style for the plots
plt.style.use('bmh')
# ==========================================
# Graph 1: Line Graph - Memory Storage Overhead Over Time
# Compares O(1) memory footprint vs. Linear growth of raw logging
# ==========================================
def generate_memory_line_graph():
# 72-hour stress test
time_hours = np.linspace(0, 72, 100)
# Standard raw logging: 15,000 events/sec * 3600 sec/hr = 54,000,000 events/hr
# Assuming ~500 bytes per raw log event = ~27 GB per hour
standard_storage_gb = time_hours * 27
# Proposed system: Constant 256 bytes (0.000000256 GB, practically 0 on this scale)
proposed_storage_gb = np.zeros_like(time_hours)
plt.figure(figsize=(8, 5))
plt.plot(time_hours, standard_storage_gb, label="Standard Raw Logging (Linear Growth)",
color='#e74c3c', linestyle='--', linewidth=2.5)
plt.plot(time_hours, proposed_storage_gb, label="Proposed System ($O(1)$ Accumulator)",
color='#2ecc71', linewidth=3)
plt.fill_between(time_hours, standard_storage_gb, color='#e74c3c', alpha=0.1)
plt.xlabel("Time (Hours)", fontweight='bold')
plt.ylabel("Cumulative Storage Size (Gigabytes)", fontweight='bold')
plt.title("Memory Overhead Over 72-Hour Stress Test", fontsize=14, fontweight='bold', pad=15)
plt.legend(loc="upper left")
plt.grid(True, linestyle=':', alpha=0.7)
plt.tight_layout()
plt.savefig("Graph1_Memory_Line_Graph.png", dpi=300)
plt.close()
print("Generated: Graph1_Memory_Line_Graph.png")
# ==========================================
# Graph 2: Bar Graph - Network Payload Size Comparison
# Shows the 98.4% reduction in bandwidth
# ==========================================
def generate_network_bar_graph():
methods = ["Standard Batch-Logging\n(Raw Logs)", "Proposed System\n(Cryptographic Witness)"]
# 98.4% reduction implies the proposed payload is 1.6% of the standard payload.
# We will use a logarithmic scale to show the massive difference cleanly.
# Assuming standard batch is ~16,000 bytes compared to the 256 byte witness.
payload_sizes = [16000, 256]
plt.figure(figsize=(7, 5))
bars = plt.bar(methods, payload_sizes, color=['#34495e', '#3498db'], edgecolor='black', width=0.6)
plt.yscale('log')
plt.ylabel("Payload Size per Epoch (Bytes) - Log Scale", fontweight='bold')
plt.title("Network Bandwidth Consumption per Epoch", fontsize=14, fontweight='bold', pad=15)
# Add data labels on top of bars
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval * 1.2,
f"{int(yval):,} Bytes", ha='center', va='bottom', fontweight='bold')
# Add the percentage drop text
plt.annotate('98.4% Reduction',
xy=(1, 256), xytext=(0.5, 1000),
arrowprops=dict(facecolor='red', shrink=0.05, width=2, headwidth=8),
fontsize=12, fontweight='bold', color='red', ha='center')
plt.tight_layout()
plt.savefig("Graph2_Network_Bar_Graph.png", dpi=300)
plt.close()
print("Generated: Graph2_Network_Bar_Graph.png")
# ==========================================
# Graph 3: Horizontal Bar Graph - Processing Latency
# Details the millisecond benchmarks for the system
# ==========================================
def generate_latency_bar_graph():
tasks = ["Dynamic Witness Update\n(Continuous Ingestion)",
"Smart Contract\nVerification (Ledger)",
"Epoch Witness Computation\n(Asynchronous Trigger)"]
# Latencies in milliseconds
times = [10, 30, 45]
plt.figure(figsize=(8, 4))
bars = plt.barh(tasks, times, color=['#9b59b6', '#f39c12', '#16a085'], edgecolor='black', height=0.5)
plt.xlabel("Processing Time (Milliseconds)", fontweight='bold')
plt.title("System Processing Latency Benchmarks", fontsize=14, fontweight='bold', pad=15)
# Add text labels inside/next to the bars
for i, bar in enumerate(bars):
width = bar.get_width()
plt.text(width - 2, bar.get_y() + bar.get_height()/2,
f"< {width} ms" if width != 45 else f"~ {width} ms",
ha='right', va='center', color='white', fontweight='bold', fontsize=11)
plt.xlim(0, 55) # Give some padding on the right
plt.tight_layout()
plt.savefig("Graph3_Latency_Bar_Graph.png", dpi=300)
plt.close()
print("Generated: Graph3_Latency_Bar_Graph.png")
# Execute the functions
if __name__ == "__main__":
generate_memory_line_graph()
generate_network_bar_graph()
generate_latency_bar_graph()
print("All graphs successfully generated!")
|