Disk I/O optimization

The Impact of Disk I/O Optimization on MongoDB Performance

As a document-oriented database, MongoDB's performance heavily relies on disk I/O efficiency. In high-concurrency scenarios, improper disk operations can lead to query latency, write blocking, and other issues. Through reasonable index design, storage engine tuning, and hardware configuration, database response speed can be significantly improved.

Storage Engine Selection and Configuration

WiredTiger Engine Optimization

WiredTiger is MongoDB's default storage engine, utilizing copy-on-write and compression technologies:

// Specify storage engine parameters when creating a collection
db.createCollection("logs", {
  storageEngine: {
    wiredTiger: {
      configString: "block_compressor=zstd,allocation_size=4KB"
    }
  }
})

Key parameter configurations:

• block_compressor: Recommended zstd algorithm for balanced compression ratio and performance
• cache_size: Typically set to 50-70% of physical memory
• journal_compressor: Choose snappy for journal compression algorithm

Memory-Mapped Tuning

For the MMAPv1 engine (deprecated but still used in legacy systems):

# /etc/mongod.conf
storage:
  mmapv1:
    preallocDataFiles: false
    smallFiles: true
    journal:
      commitIntervalMs: 100

Index Optimization Strategies

Covered Index Design

// Create compound indexes to cover common queries
db.orders.createIndex({ customerId: 1, createdAt: -1, status: 1 })

// Use hint to force index usage in queries
db.orders.find(
  { customerId: "123", status: "shipped" },
  { _id: 0, createdAt: 1, amount: 1 }
).hint("customerId_1_createdAt_-1_status_1")

Index Compression Optimization

WiredTiger supports prefix compression:

db.products.createIndex(
  { name: 1, category: 1 },
  { compression: "prefix" }
)

Data Sharding and Storage Planning

Hot Data Separation

Place frequently accessed data on high-performance storage:

// Create a collection on SSD
db.createCollection("hot_data", {
  storageEngine: {
    wiredTiger: {
      configString: "type=file,allocation_size=4KB,directory_for_indexes=/ssd/indexes"
    }
  }
})

Shard Key Selection Principles

Avoid monotonically increasing shard keys that cause write hotspots:

// Use hashed shard keys to distribute writes
sh.shardCollection("db.logs", { _id: "hashed" })

// Example of compound shard keys
sh.shardCollection("db.events", { region: 1, timestamp: 1 })

Filesystem and Hardware Optimization

Filesystem Mount Parameters

Recommended XFS filesystem configuration:

# /etc/fstab
/dev/sdb1 /data xfs noatime,nodiratime,nobarrier,logbsize=256k 0 0

RAID Configuration Recommendations

• RAID 10: Best write performance
• RAID 5: Suitable for read-intensive scenarios
• Disable RAID card cache or use battery backup

Write Optimization Techniques

Batch Insert Mode

// Reduce IOPS with batch inserts
const bulk = db.items.initializeUnorderedBulkOp()
for (let i = 0; i < 1000; i++) {
  bulk.insert({ sku: `item${i}`, stock: Math.floor(Math.random()*100) })
}
bulk.execute({ w: 1, j: false })

Write Concern Level Adjustment

Balance safety and performance based on business needs:

// Reduce write concern for non-critical data
db.logs.insert(
  { event: "click", time: new Date() },
  { writeConcern: { w: 1, j: false } }
)

Monitoring and Diagnostic Tools

Built-in Command Analysis

// View current operations
db.currentOp(true)

// Collect I/O statistics
db.serverStatus().wiredTiger.cache

Performance Profiling

// Enable slow query logging
db.setProfilingLevel(1, { slowms: 50 })

// Analyze query plans
db.orders.find({ status: "pending" }).explain("executionStats")

Operating System-Level Tuning

Kernel Parameter Adjustment

# Increase file descriptor limit
echo "* soft nofile 100000" >> /etc/security/limits.conf

# Adjust virtual memory parameters
sysctl -w vm.dirty_ratio=10
sysctl -w vm.dirty_background_ratio=5

NUMA Architecture Optimization

# Disable NUMA balancing when starting MongoDB
numactl --interleave=all mongod --config /etc/mongod.conf

Impact of Backup Strategies on I/O

Hot Backup Techniques

// Minimize backup impact with fsyncLock
db.fsyncLock()
// Perform filesystem snapshots
db.fsyncUnlock()

Oplog Adjustment

# Increase oplog size to reduce disk seeks
replication:
  oplogSizeMB: 2048
  secondaryIndexPrefetch: "all"

Special Scenario Handling

Large Document Storage Optimization

Documents exceeding 16MB require GridFS:

const bucket = new GridFSBucket(db, {
  bucketName: "videos",
  chunkSizeBytes: 255 * 1024 // Adjust chunk size
})

Time-Series Data

// Create time-series collections
db.createCollection("sensor_data", {
  timeseries: {
    timeField: "timestamp",
    metaField: "sensorId",
    granularity: "hours"
  },
  expireAfterSeconds: 86400
})