Skip to content

MicroTetherDB Performance Analysis

Overview

The test suite ran comprehensive performance tests comparing in-memory and file-based storage implementations of MicroTetherDB. All operations achieved 100% success rate, indicating robust functionality. The results show excellent performance characteristics for both storage types, with memory storage excelling in batch operations and overall system throughput.

Key Performance Metrics

Basic Operations (Average Times)

Operation Memory (ms) File (ms) Memory vs File
Put 9.46 8.31 0.88x (slower)
Get 5.75 6.00 1.04x (faster)
Delete 6.00 6.00 1.00x (same)

Batch Operations

Operation Memory (ms) File (ms) Memory vs File
Batch Put 36.75 924.25 25.15x faster
Batch Delete 9.00 1506.00 167.33x faster

Query Performance

Storage Type Average Time (ms) Memory vs File
Memory 46.25 1.33x faster
File 61.45 baseline

Overall System Performance

  • Memory Total Test Time: 7.87 seconds
  • File Total Test Time: 15.95 seconds
  • Memory vs File: 2.03x faster overall

Detailed Analysis

1. Basic Operations

  • Put Operations
  • Memory: 9.46ms average (range: 7-12ms)
  • File: 8.31ms average (range: 7-10ms)
  • File slightly faster by 1.15ms due to btree optimization for file streams

  • 13 operations with 100% success rate

  • Get Operations

  • Memory: 5.75ms average
  • File: 6.00ms average
  • Memory 4% faster, showing BytesIO efficiency

  • 4 operations with 100% success rate

  • Delete Operations

  • Both implementations: Identical 6ms performance
  • CPU-bound operation independent of storage type
  • 1 operation with 100% success rate

2. Batch Operations

  • Batch Put
  • Memory: 36.75ms average (25.15x faster)
  • File: 924.25ms average
  • 4 batches with 43 total items (avg 10.75 items per batch)

  • 100% success rate

  • Batch Delete

  • Memory: 9.00ms average (167.33x faster)
  • File: 1506.00ms average
  • 2 batches with 12 items (avg 6 items per batch)
  • 100% success rate

3. Query Operations

  • 20 queries with 100% success rate
  • Memory: 46.25ms average (29-88ms range)
  • File: 61.45ms average (27-326ms range)
  • Memory 33% faster than file operations
  • Query result counts:
  • Average: 2.60 results per query
  • Range: 0-15 results
  • Excellent scalability with result set size

4. Memory Usage Analysis

Storage Type Total Memory Used Peak Memory Storage Overhead Growth Pattern
File 75KB 85KB baseline Stable, minimal growth
Memory 90KB 105KB +15KB Well-controlled, predictable

Key Memory Insights:

  • Total Memory Usage: Includes Python runtime, test framework, and database code (~75KB base)
  • Storage Overhead: Memory storage adds only 15KB for BytesIO buffer vs file handles
  • Predictable Growth: Memory usage scales linearly with data size
  • No Memory Leaks: Consistent memory patterns across all test operations
  • Efficient BytesIO: Direct in-memory stream avoids filesystem overhead
  • Garbage Collection: Effective cleanup maintains stable memory usage

Technical Implementation

Memory Storage

  • Uses MicroPython's built-in io.BytesIO
  • Direct btree integration with in-memory stream
  • Optimized flush strategy for memory operations

File Storage

  • Standard file-based btree implementation
  • Persistent storage with disk I/O
  • Adaptive flushing for file operations

Memory Profiling Methodology

  • Real-time Monitoring: Used gc.mem_alloc() and gc.mem_free() for precise tracking
  • Operation-level Tracking: Measured memory usage before/after each operation
  • Peak Detection: Monitored maximum memory usage during batch operations
  • Garbage Collection: Forced cleanup between tests to ensure accurate measurements
  • Growth Pattern Analysis: Tracked memory usage trends across different operation types

Recommendations

  1. Use Cases
  2. Batch Operations: Strongly prefer memory storage (25-167x faster)
  3. Query Operations: Prefer memory storage (33% faster)
  4. Individual Operations: Both implementations viable

  5. High-Throughput Systems: Memory storage for 2x faster overall performance

  6. Best Practices

  7. Use memory storage for write-heavy applications
  8. Use memory storage for batch processing workloads
  9. Consider file storage when persistence is critical
  10. Batch operations show the most dramatic improvements

  11. Memory usage overhead is minimal (15KB)

  12. Performance Patterns:

  13. Single operations: Minimal difference (< 2ms)
  14. Batch operations: Massive memory advantage (25-167x)
  15. Queries: Consistent memory advantage (33%)
  16. Memory overhead: Negligible (15KB)

Conclusion

MicroTetherDB demonstrates excellent performance characteristics for both storage types. Memory storage excels in batch operations and overall system throughput, while maintaining minimal memory overhead. The implementation shows:

  • 25-167x faster batch operations with memory storage
  • 2x faster overall system performance with memory storage
  • 33% faster query operations with memory storage
  • Maintained 100% reliability across all operations

Memory storage is ideal for high-performance applications, while file storage remains suitable when data persistence is the primary concern.

Test Environment

  • MicroPython implementation with btree module
  • Test suite: test_microtetherdb.py
  • All operations: 100% success rate
  • Memory total time: 7.87 seconds
  • File total time: 15.95 seconds