Performance Tuning

Optimize LilChunks for maximum performance and minimal server impact

Performance Tuning

Optimize LilChunks to achieve the best balance between generation speed and server performance.

Performance Overview

LilChunks is designed to be highly performant, but proper configuration is essential for optimal results:

CPU Usage

Multi-threaded generation with configurable thread count

Memory Management

Smart memory usage with optional limits

Server Impact

Minimal TPS impact with async processing

Performance Metrics

Key Performance Indicators

Monitor these metrics during chunk generation:

TPS (Ticks Per Second)

Target: 20 TPS
Acceptable: 18+ TPS
Critical: Below 15 TPS

# Check TPS
/tps

# Typical output during generation
TPS: 19.8, 19.5, 19.2 (1m, 5m, 15m avg)

If TPS drops below 15, reduce generation speed immediately.

Memory Usage

Monitor: Heap memory usage
Warning: Above 80% usage
Critical: Above 90% usage

# Check memory
/memory

# Or use system commands
free -h
htop

Generation Speed

Measurement: Chunks per second
Typical Range: 5-50 chunks/second
Depends On: Server specs and configuration

# Check generation status
/lc status
# Shows: Speed: 12 chunks/second

Configuration Optimization

Performance Profiles

Choose a profile based on your server specifications:

High-End Server

Specs: 8+ cores, 16+ GB RAM, NVMe SSD

chunk-generation:
  chunks-per-tick: 8
  use-async: true
  generate-structures: true
  generate-caves: true
  generate-features: true

performance:
  max-memory-usage: 0
  use-parallel: true
  thread-count: 0  # Auto-detect

logging:
  progress-interval: 3

Expected Performance: 30-50 chunks/second

Fine-Tuning Parameters

chunks-per-tick

Impact: Direct effect on generation speed and server load

Tuning Guide:

• Start with default (4)
• Monitor TPS during generation
• Increase if TPS stays above 18
• Decrease if TPS drops below 16

# Conservative (minimal lag)
chunks-per-tick: 1-2

# Balanced (recommended)
chunks-per-tick: 3-5

# Aggressive (high-end servers)
chunks-per-tick: 6-12

thread-count

Impact: CPU utilization and parallel processing

Recommendations:

• 0: Auto-detect (CPU cores - 1)
• 1: Single-threaded (lowest impact)
• 2-4: Good for most servers
• 6+: High-end servers only

# Let LilChunks decide (recommended)
thread-count: 0

# Manual control
thread-count: 4  # For 6+ core servers
thread-count: 2  # For 4 core servers
thread-count: 1  # For 2 core servers

max-memory-usage

Impact: Memory consumption and garbage collection

Guidelines:

• 0: No limit (high-end servers)
• 1024-2048: Most servers
• 512-1024: Budget servers
• 256-512: Shared hosting

# No memory limit (if you have plenty)
max-memory-usage: 0

# Conservative limit
max-memory-usage: 1024  # 1GB

# Strict limit
max-memory-usage: 512   # 512MB

Real-Time Optimization

Dynamic Adjustment

Monitor and adjust settings during generation:

1. Start Generation

   Begin with conservative settings:

   /lc start 10
   

2. Monitor Performance

   Check TPS and memory every 30 seconds:

   /tps
   /memory
   /lc status
   

3. Adjust if Needed

   If performance is good, increase speed:

   # Edit config.yml
   chunks-per-tick: 6  # Increase from 4
   

   /lc reload
   

4. Continue Monitoring

   Keep watching performance and adjust as needed.

Performance Indicators

Good Performance

TPS: 19.8, 19.5, 19.2
Memory: 45% used
Generation: 15 chunks/second

Action: Consider increasing generation speed

Server-Specific Optimizations

Paper Server

Paper provides additional optimizations:

# paper-world-defaults.yml
chunks:
  auto-save-interval: 6000  # Increase from default
  delay-chunk-unloads-by: 10s
  
entities:
  spawning:
    per-player-mob-spawns: true
    
misc:
  use-faster-eigencraft-redstone: true

Spigot Server

Spigot configuration tweaks:

# spigot.yml
world-settings:
  default:
    mob-spawn-range: 6  # Reduce from 8
    entity-activation-range:
      animals: 16
      monsters: 24
      raiders: 48
      misc: 8

JVM Optimization

Optimize Java Virtual Machine settings:

# Recommended JVM flags for chunk generation
java -Xms4G -Xmx8G \
     -XX:+UseG1GC \
     -XX:+ParallelRefProcEnabled \
     -XX:MaxGCPauseMillis=200 \
     -XX:+UnlockExperimentalVMOptions \
     -XX:+DisableExplicitGC \
     -XX:+AlwaysPreTouch \
     -XX:G1NewSizePercent=30 \
     -XX:G1MaxNewSizePercent=40 \
     -XX:G1HeapRegionSize=8M \
     -XX:G1ReservePercent=20 \
     -XX:G1HeapWastePercent=5 \
     -XX:G1MixedGCCountTarget=4 \
     -XX:InitiatingHeapOccupancyPercent=15 \
     -XX:G1MixedGCLiveThresholdPercent=90 \
     -XX:G1RSetUpdatingPauseTimePercent=5 \
     -XX:SurvivorRatio=32 \
     -XX:+PerfDisableSharedMem \
     -XX:MaxTenuringThreshold=1 \
     -jar server.jar nogui

Monitoring Tools

Built-in Monitoring

Use LilChunks’ built-in monitoring:

# Check generation status
/lc status

# Enable detailed logging temporarily
# Edit config.yml:
debug: true
logging:
  detailed-logs: true

# Reload and monitor logs
/lc reload

External Monitoring

Server Plugins

# Install monitoring plugins
- LagMonitor
- Spark
- ServerUtils
- TPS Monitor

# Use commands
/spark profiler start
/lagmonitor
/tps

Troubleshooting Performance Issues

Low TPS During Generation

Symptoms: TPS drops below 15 during chunk generation

Solutions:

1. Reduce chunks-per-tick to 1-2
2. Disable parallel processing
3. Set memory limits
4. Reduce thread count
5. Disable structure/feature generation

chunk-generation:
  chunks-per-tick: 1
  generate-structures: false
  generate-features: false
performance:
  use-parallel: false
  thread-count: 1

High Memory Usage

Symptoms: Memory usage above 80%, frequent GC pauses

Solutions:

1. Set strict memory limits
2. Reduce generation speed
3. Increase heap size
4. Optimize JVM flags

performance:
  max-memory-usage: 1024  # 1GB limit
chunk-generation:
  chunks-per-tick: 2      # Reduce speed

Slow Generation Speed

Symptoms: Very slow chunk generation (< 5 chunks/second)

Solutions:

1. Check disk I/O performance
2. Verify async is enabled
3. Increase thread count
4. Check for plugin conflicts

chunk-generation:
  use-async: true
  chunks-per-tick: 4
performance:
  use-parallel: true
  thread-count: 0  # Auto-detect

Server Freezing

Symptoms: Server becomes unresponsive during generation

Solutions:

1. Stop generation immediately
2. Use minimal settings
3. Check for deadlocks
4. Review server logs

# Emergency stop
/lc stop

# Use minimal settings
chunks-per-tick: 1
use-parallel: false
thread-count: 1

Performance Best Practices

Start Conservative

Begin with lower settings and gradually increase based on performance monitoring.

Monitor Continuously

Keep an eye on TPS, memory, and generation speed throughout the process.

Off-Peak Generation

Run large pregeneration tasks during low-activity periods.

Backup Before Large Tasks

Always backup your world before running extensive pregeneration.

Test Configuration

Test new configurations on a development server first.

Document Settings

Keep notes on what settings work best for your server setup.

Performance Benchmarks

Typical Performance Ranges

Based on server specifications:

Server Type	CPU Cores	RAM	Storage	Expected Speed
High-End Dedicated	8+	16+ GB	NVMe SSD	30-50 chunks/s
Mid-Range VPS	4-6	8-12 GB	SSD	15-25 chunks/s
Budget VPS	2-4	4-6 GB	SSD/HDD	5-12 chunks/s
Shared Hosting	1-2	2-4 GB	HDD	2-8 chunks/s

Optimization Results

Example of optimization impact:

Before Optimization

Configuration:
- chunks-per-tick: 4 (default)
- use-parallel: true
- thread-count: 0
- No memory limit

Results:
- TPS: 12-15 (poor)
- Memory: 90% usage
- Speed: 3 chunks/second

Next Steps

Troubleshooting Guide

Solve common performance and other issues

API Documentation

Integrate LilChunks with other plugins