Skip to content

Plotter Guide

Jump to bottom
JohnnyFFM edited this page Oct 15, 2025 · 1 revision

PoCX Plotter User Guide

Version: 1.0.0 Last Updated: 2025-10-13

Wiki Navigation: Plotter Guide (you are here) | Miner Guide | Plot Format | Technical Details

Table of Contents

Introduction

What is Plotting?

Plotting is the process of pre-computing cryptographic data and storing it on hard drives for use in Proof-of-Capacity (PoC) mining. Plot files contain thousands of pre-calculated hash values that miners use to participate in blockchain consensus without continuous high CPU usage.

Why Plot Files Are Needed

Unlike Proof-of-Work mining that requires continuous computation, PoC mining uses pre-computed data stored in plot files. Once created, these files enable energy-efficient mining by simply reading stored values from disk rather than recalculating them repeatedly.

PoCX Plotter Features

  • High-performance CPU plotting with automatic SIMD optimization (SSE2/AVX/AVX2/AVX512)
  • GPU acceleration via OpenCL (Intel/AMD/NVIDIA GPUs)
  • Multi-GPU support for parallel plotting
  • Hybrid CPU+GPU plotting for maximum throughput
  • Direct I/O for optimal disk performance
  • Resume capability for interrupted plots
  • Compression levels with scalable Proof-of-Work
  • Benchmark mode for performance testing

Requirements

Operating Systems

  • Linux: Fully supported (kernel 2.6+, glibc 2.17+)
  • Windows: Fully supported (Windows 10 1809+ or Windows 11)
  • macOS: Fully supported (macOS 10.15 Catalina or later)

Hardware Requirements

Minimum

  • CPU: x86_64 processor with SSE2 support (all modern 64-bit CPUs)
  • RAM: 2 GB
  • Storage: 10 GB for testing (1-10 TB typical for production)

Recommended

  • CPU: Multi-core processor with AVX2 or AVX512 support
  • RAM: 8-16 GB for optimal performance
  • Storage: High-capacity HDDs or SSDs with good sequential write speeds

GPU Plotting (Optional)

  • GPU: OpenCL-compatible GPU (Intel/AMD/NVIDIA)
  • VRAM: Varies by configuration (typically 2-8 GB)
  • OpenCL: Version 1.2 or later

Software Requirements

  • Rust: 1.91.0-nightly or later (for building from source)
  • OpenCL: For building with GPU support, you need OpenCL development headers (Linux: included in -dev packages; Windows/macOS: bundled with GPU drivers). For running pre-built binaries with GPU support, only GPU drivers are required

Installation

Option 1: Building from Source

Step 1: Install Rust Nightly Toolchain

If you don't have Rust installed, visit rustup.rs and follow the installation instructions.

# Install nightly toolchain
rustup toolchain install nightly --component rustfmt clippy

# Navigate to PoCX directory
cd /path/to/pocx

# Set nightly as default for this project
rustup override set nightly

Step 2: Build PoCX Plotter

CPU-only build (no OpenCL):

cargo build --release -p pocx_plotter

Build with OpenCL support:

cargo build --release -p pocx_plotter --features opencl

Step 3: Locate Binary

After successful build, the plotter binary will be at:

./target/release/pocx_plotter

Optional: Copy to system PATH:

sudo cp ./target/release/pocx_plotter /usr/local/bin/

Option 2: Pre-built Binaries

Pre-built binaries may be available from GitHub Releases (check for availability).

OpenCL Installation (For GPU Support)

Linux

Intel GPUs:

sudo apt install intel-opencl-icd ocl-icd-opencl-dev

AMD GPUs:

sudo apt install mesa-opencl-icd ocl-icd-opencl-dev

NVIDIA GPUs:

sudo apt install nvidia-opencl-dev ocl-icd-opencl-dev

Windows

  • Intel: Install Intel Graphics Driver
  • AMD: Install AMD Radeon Software
  • NVIDIA: Install NVIDIA GPU Driver (includes OpenCL)

macOS

OpenCL is included with macOS (deprecated in 10.14+ but still functional).

Verify OpenCL Installation

# List available OpenCL platforms and devices
./target/release/pocx_plotter -o

Quick Start

Basic CPU Plotting

Create a 10 GiB plot using default settings:

pocx_plotter -i pocx1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqc5hpgp -p /path/to/plots -w 10

Parameters:

  • -i: Your PoC mining address
  • -p: Directory where plot files will be saved
  • -w: Number of warps (1 warp = 1 GiB = 1,073,741,824 bytes)

Multi-threaded CPU Plotting

Use specific number of CPU threads:

pocx_plotter -i <address> -p /path/to/plots -w 100 -c 16

Note: If not specified, plotter uses all available CPU cores.

GPU-Accelerated Plotting

First, discover available GPUs:

pocx_plotter -o

Example output:

Platform 0: Intel(R) OpenCL HD Graphics
  Device 0: Intel(R) UHD Graphics 630 [24 compute units, max workgroup: 256]

Platform 1: NVIDIA CUDA
  Device 0: NVIDIA GeForce RTX 3080 [68 compute units, max workgroup: 1024]

Plot using GPU:

pocx_plotter -i <address> -p /path/to/plots -w 500 -g 1:0:4096

GPU parameter format: platform:device:cores

  • Platform 1, Device 0, 4096 cores

GPU-Only Plotting (No CPU)

When you specify GPU without CPU threads, CPU is automatically disabled:

pocx_plotter -i <address> -p /path/to/plots -w 500 -g 0:0:1024

Hybrid CPU+GPU Plotting

Combine both for maximum throughput:

pocx_plotter -i <address> -p /path/to/plots -w 1000 -c 8 -g 0:0:2048

Multiple GPU Plotting

Plot with multiple GPUs simultaneously:

pocx_plotter -i <address> -p /path/to/plots -w 2000 -g 0:0:2048 -g 0:1:2048

High Compression Plotting

Use compression level for increased Proof-of-Work:

pocx_plotter -i <address> -p /path/to/plots -w 500 -x 4

Compression levels:

  • -x 1: X1 = 2^1 = 2x scaling (default)
  • -x 2: X2 = 2^2 = 4x scaling
  • -x 3: X3 = 2^3 = 8x scaling
  • -x 4: X4 = 2^4 = 16x scaling

Higher compression requires exponentially more memory and computation time.

Fill Disk Automatically

Let plotter calculate optimal warp count:

pocx_plotter -i <address> -p /mnt/disk1 -w 0 -n 5

This creates 5 plot files, automatically sizing each to fill available disk space.

Multiple Output Directories

Plot to multiple disks in parallel:

pocx_plotter -i <address> -p /mnt/disk1 -p /mnt/disk2 -p /mnt/disk3 -w 1000

Creates one 1 TiB plot file on each disk simultaneously.

Resume Interrupted Plot

If plotting is interrupted, you can resume using the seed:

# Original plot command
pocx_plotter -i <address> -p /plots -w 1000 -n 1

# After interruption, check plot file for seed (in filename)
# Format: ADDRESS_SEED_WARPS_X1.tmp
# Example: 1234567890abcdef_5656565656565656565656565656565656565656565656565656565656565656_1000_X1.tmp

# Resume with seed
pocx_plotter -i <address> -p /plots -w 1000 -n 1 -s 5656565656565656565656565656565656565656565656565656565656565656

Requirements for resume:

  • Must specify -n 1 (single plot file)
  • Must use same address, path, warps, and compression
  • Seed must be exactly 64 hexadecimal characters

Benchmark Mode

Test plotting performance without writing files:

pocx_plotter -i <address> -b -w 100

Useful for:

  • Testing hardware capabilities
  • Comparing CPU vs GPU performance
  • Verifying SIMD optimization detection

Command Line Reference

Required Arguments

Flag Long Form Type Description
-i --id <address> String PoC mining address (Base58 or Bech32 format)

Core Plotting Options

Flag Long Form Type Default Description
-w --warps <warps> u64 0 Number of warps to plot (1 warp = 1 GiB)
-n --num <number> u64 1 Number of plot files to generate
-p --path <path> String . Target disk path(s), can be specified multiple times
-x --compression <level> u8 1 POW scaling factor (2^level)

Warp calculation:

  • If -w 0 and -n > 0: Auto-calculate warps to fill disk
  • If -w > 0: Use specified warp count per file
  • 1 warp = 1 GiB = 1,073,741,824 bytes exactly

CPU Configuration

Flag Long Form Type Default Description
-c --cpu <threads> usize All cores Number of CPU threads to use

Behavior:

  • Default: Uses all available CPU cores
  • Max: Capped at 2× physical cores
  • If GPU specified without -c: CPU threads = 0 (GPU-only mode)

OpenCL GPU Options

Flag Long Form Type Description
-g --gpu <config> String GPU configuration: platform:device:cores
-o --opencl Flag List OpenCL platforms/devices and exit
-z --zcb Flag Enable zero-copy buffers (integrated GPUs)
-k --kws-override <size> usize Override kernel workgroup size

GPU configuration format:

-g platform_id:device_id:cores
  • platform_id: OpenCL platform index (from -o output)
  • device_id: Device index within platform
  • cores: Number of cores to use (0 = use all available)

Zero-copy buffers (-z):

  • Recommended for integrated GPUs (Intel HD Graphics, AMD APUs)
  • Reduces memory usage by half
  • Not beneficial for discrete GPUs with dedicated VRAM

Advanced Options

Flag Long Form Type Default Description
-s --seed <seed> String Random 64-character hex seed for resuming plots
-m --mem <memory> String "0B" Memory limit (e.g., 8GiB, 512MiB)
-e --escalate <mult> u64 1 Buffer multiplier (increases memory usage)

Seed format:

  • Exactly 64 hexadecimal characters (0-9, a-f, A-F)
  • Example: 1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef
  • Used for resume only (requires -n 1)

Memory limit format:

  • Units: B, KiB, MiB, GiB, TiB, PiB, EiB (binary)
  • Units: KB, MB, GB, TB, PB, EB (decimal)
  • Examples: --mem 10GiB, --mem 512MiB
  • Validation: Cannot exceed 2× available system memory

Escalate multiplier:

  • Increases buffer sizes for better performance
  • Memory usage = base × escalate
  • Higher values require more RAM

Global Flags

Flag Long Form Description
-d --ddio Disable direct I/O (enabled by default)
-l --prio Run plotter with low priority
-q --quiet Run in non-verbose mode (suppresses progress)
-b --bench Benchmark mode (no file writes)

Direct I/O:

  • Enabled by default for maximum performance
  • Bypasses OS page cache
  • Automatically disabled if sector size not power of 2 or > 256 KiB
  • Use -d to disable manually

Address Format

Supported Formats

PoCX plotter currently implements two address formats, both using 20-byte account IDs:

Base58 Format

Example: b1A2B3C4D5E6F7G8H9JKLMNPQRSTUVWXYZabcdefgh

  • Network-specific version byte
  • 4-byte checksum for validation
  • Used by Burst, BHD, and other POC1/POC2 chains

Bech32 Format

Example: burst1... or pocx1...

  • Human-readable prefix (HRP)
  • Error detection via checksum
  • More robust against typos

Address Requirements

  • Length: 1-90 characters
  • Validation: Must decode to valid 20-byte payload
  • Network independence: Plot files store only the payload, making them usable across different networks

How to Get Your Address

Obtain a mining address from wallet software for the PoC blockchain you're mining.

Network Independence

PoCX plot files store only the 20-byte address payload (network-independent format). The plotter extracts this payload and uses it in the plot filename:

Format: <ADDRESS_HEX>_<SEED>_<WARPS>_X<COMPRESSION>.pocx
Example: 1212121212121212121212121212121212121212_5656...5656_1024_X1.pocx

Cross-chain compatibility: Plot files work across blockchains only if they derive the same 20-byte payload from your address. Different address derivation schemes require separate plot files.

Hex Payload Format

You can also specify the address as a 40-character hex string (20 bytes):

pocx_plotter -i 1212121212121212121212121212121212121212 -p /plots -w 100

GPU Plotting (OpenCL)

Overview

GPU plotting can significantly accelerate plot generation, especially for high-compression plots. PoCX supports OpenCL 1.2+ compatible GPUs from Intel, AMD, and NVIDIA.

Setup

Step 1: Install OpenCL Runtime

See Installation - OpenCL section above.

Step 2: Build with OpenCL Support

cargo build --release -p pocx_plotter --features opencl

Step 3: List Available Devices

pocx_plotter -o

Example output:

OpenCL Platforms and Devices:

Platform 0: Intel(R) OpenCL HD Graphics
  Device 0: Intel(R) UHD Graphics 630
    Vendor: Intel(R) Corporation
    Compute Units: 24
    Max Workgroup Size: 256

Platform 1: NVIDIA CUDA
  Device 0: NVIDIA GeForce RTX 3080
    Vendor: NVIDIA Corporation
    Compute Units: 68
    Max Workgroup Size: 1024

Configuration

Basic GPU Plotting

pocx_plotter -i <address> -p /plots -w 500 -g 0:0:1024

Parameter breakdown:

  • -g 0:0:1024
    • Platform: 0 (Intel OpenCL)
    • Device: 0 (first GPU)
    • Cores: 1024 (use 1024 compute units)

Optimal Core Count

Recommendation: Start with a multiple of max workgroup size.

For example, if max workgroup size = 256:

  • Try: 256, 512, 1024, 2048
  • Experiment to find best performance

Auto-detect (use all cores):

pocx_plotter -i <address> -p /plots -w 500 -g 0:0:0

Setting cores to 0 uses all available compute units.

Multi-GPU Setup

Plot with multiple GPUs for maximum throughput:

pocx_plotter -i <address> -p /plots -w 2000 -g 0:0:2048 -g 1:0:4096

This uses:

  • Platform 0, Device 0 with 2048 cores
  • Platform 1, Device 0 with 4096 cores

Integrated vs Discrete GPUs

Integrated GPUs (Intel HD, AMD APUs)

Use zero-copy buffers to reduce memory usage:

pocx_plotter -i <address> -p /plots -w 500 -g 0:0:1024 -z

The -z flag enables zero-copy buffers, reducing GPU memory usage by 50%.

Discrete GPUs (NVIDIA, AMD)

Do not use zero-copy buffers for discrete GPUs with dedicated VRAM:

pocx_plotter -i <address> -p /plots -w 500 -g 0:0:4096

Performance Tips

  1. Start with GPU-only mode to test maximum GPU performance:

    pocx_plotter -i <address> -p /plots -w 100 -g 0:0:2048

  2. Add CPU if GPU isn't fully utilized:

    pocx_plotter -i <address> -p /plots -w 100 -c 4 -g 0:0:2048

  3. Benchmark to compare configurations:

    pocx_plotter -i <address> -b -w 100 -g 0:0:2048

Memory Requirements

GPU plotting requires VRAM based on configuration:

Formula:

VRAM = 2 × cores × workgroup_size × 256 KiB

Example (36 cores, workgroup 256):

VRAM = 2 × 36 × 256 × 256 KiB = 4.5 GiB

The plotter validates VRAM availability at startup and will error if insufficient.

Troubleshooting GPU Issues

See Troubleshooting - OpenCL Issues section below.

Understanding Output

Startup Information

PoCX Plotter 1.0.0
written by Proof of Capacity Consortium in Rust

CPU: AMD Ryzen 9 5950X 16-Core Processor [using 32 of 32 cores + AVX2]
RAM: Total=64.0 GiB, Available=48.2 GiB, Usage=12.5 GiB
     Cache(Plotter)=2.0 GiB x1, Cache(HDD)=1.0 GiB x1 x3, Cache(GPU)=0.5 GiB

Address       : pocx1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqc5hpgp
Address Hex   : 1212121212121212121212121212121212121212 (network-independent payload)
Compression   : 2(X1)
Output path(s): [/mnt/disk1, /mnt/disk2, /mnt/disk3]
Files to plot : [1, 1, 1]
Warps per file: [1024, 1024, 1024]
Total warps   : 3072

Starting plotting...

Key information:

  • CPU: Processor name, threads used, SIMD extension detected
  • RAM: Total, available, and plotter memory usage
  • Cache: Plotter cache, HDD cache per disk, GPU cache (if applicable)
  • Address: Input address and hex payload
  • Compression: PoW scaling factor
  • Output paths: Disk paths and warps per file
  • Total warps: Sum of all warps across all files

Progress Bars

Two concurrent progress bars display during plotting:

Hashing: [████████████████████░░░░░░░░░░░░] 1638.4 GiB/3072.0 GiB (450.2 MiB/s, ETA 53m 28s) msg
Writing: [███████████████░░░░░░░░░░░░░░░░░] 1228.8 GiB/3072.0 GiB (382.1 MiB/s, ETA 65m 12s) msg

Progress bar components:

  • Bar: Visual representation (40 characters wide)
  • Progress: Bytes completed / total bytes
  • Speed: Current throughput (MiB/s or GiB/s)
  • ETA: Estimated time remaining
  • Message: Current operation status

Completion Message

Generated 12,582,912 nonces in 3h 24m 18s, 425.3 MiB/s, 15.2 warps/h.

Statistics:

  • Nonces: Total nonces generated (4096 nonces = 1 warp)
  • Time: Total plotting duration
  • Speed: Average throughput in MiB/s
  • Rate: Average warps per hour

Plot File Naming

During plotting (temporary):

1212121212121212121212121212121212121212_5656565656565656565656565656565656565656565656565656565656565656_1024_X1.tmp

After completion (final):

1212121212121212121212121212121212121212_5656565656565656565656565656565656565656565656565656565656565656_1024_X1.pocx

Filename format:

<ADDRESS_HEX>_<SEED_HEX>_<WARPS>_X<COMPRESSION>.<extension>
  • ADDRESS_HEX: 40 hex chars (20 bytes) - network-independent
  • SEED_HEX: 64 hex chars (32 bytes) - random or specified
  • WARPS: Number of warps (1 warp = 1 GiB)
  • COMPRESSION: X1, X2, X4, etc.
  • Extension: .tmp during plotting, .pocx when complete

Verification

After plotting completes, you can verify the plot file:

pocx_verifier check -f plot_file.pocx -m partial

This performs a quick sanity check by verifying one nonce in each scoop. For full verification (much slower), use -m complete.

Performance Optimization

CPU Optimization

SIMD Extensions

The plotter automatically detects and uses the best available SIMD instruction set:

  • AVX-512F: 64 bytes/instruction (fastest)
  • AVX2: 32 bytes/instruction
  • AVX: 32 bytes/instruction
  • SSE2: 16 bytes/instruction (baseline)
  • Fallback: Scalar operations (slowest)

Check detection in startup output:

CPU: ... [using X of Y cores + AVX2]

Ensure your system supports AVX2 or better for optimal performance.

Thread Count

Default behavior: Uses all available logical cores.

Manual tuning:

pocx_plotter -i <address> -p /plots -w 500 -c 16

Recommendations:

  • Start with all cores (default)
  • If system becomes unresponsive, reduce to 75-90% of cores
  • For hybrid CPU+GPU, reduce CPU threads to avoid bottlenecks

Thread Pinning

The plotter automatically pins threads to physical CPU cores for better cache locality. No configuration needed.

Memory Optimization

Buffer Multiplier (Escalate)

Increase buffer sizes for longer sequential writes:

pocx_plotter -i <address> -p /plots -w 500 -e 2

Effect:

  • Doubles all buffer sizes
  • Requires 2× more RAM
  • Enables longer sequential writes, improving performance on spinning hard drives

When to use:

  • Spinning hard drives (HDDs)
  • Systems with abundant RAM
  • Multiple HDDs in parallel

When to avoid:

  • Limited RAM
  • Many concurrent plots
  • NVMe/SSDs (already fast, no benefit)

Memory Limit

Limit total memory usage when plotting multiple disks:

pocx_plotter -i <address> -p /disk1 -p /disk2 -p /disk3 -w 1000 -m 16GiB

Useful for:

  • Shared systems
  • Preventing OOM (Out of Memory) errors
  • Controlling resource usage

Storage I/O Optimization

Direct I/O (Default: Enabled)

Direct I/O bypasses OS page cache for predictable performance:

pocx_plotter -i <address> -p /plots -w 500

Direct I/O is enabled by default unless:

  • Sector size is not a power of 2
  • Sector size > 256 KiB
  • Manually disabled with -d flag

Disable Direct I/O:

pocx_plotter -i <address> -p /plots -w 500 -d

When to disable:

  • Plotting to network shares (NFS, SMB)
  • Compatibility issues with filesystem
  • Testing/debugging

Filesystem Recommendations

Best:

  • ext4 (Linux): Excellent for large files, well-tested
  • XFS (Linux): Good for large files and parallel I/O
  • NTFS (Windows): Standard Windows filesystem

Acceptable:

  • Btrfs (Linux): Works but may have overhead
  • exFAT (Cross-platform): Portable but less performant

Avoid:

  • FAT32: 4 GiB file size limit (plot files are much larger)

GPU Optimization

See GPU Plotting - Performance Tips section above.

Benchmark Mode

Test different configurations without writing files:

# CPU only
pocx_plotter -i <address> -b -w 100

# GPU only
pocx_plotter -i <address> -b -w 100 -g 0:0:2048

# Hybrid
pocx_plotter -i <address> -b -w 100 -c 8 -g 0:0:2048

Compare output speeds to determine optimal configuration.

Low Priority Mode

Run plotter with reduced priority to avoid impacting other system tasks:

pocx_plotter -i <address> -p /plots -w 1000 -l

Effect:

  • Reduces CPU scheduler priority
  • Allows other applications to take precedence
  • Plotting will take longer but won't slow down your system

Troubleshooting

Common Errors

Invalid Address

Error:

Invalid address: <error details>

Causes:

  • Malformed Base58/Bech32 address
  • Invalid checksum
  • Unsupported format

Solution:

  • Verify address is correct
  • Check for typos
  • Ensure address is from a PoC-compatible blockchain
  • Try hex payload format (40 hex characters)

Insufficient Memory

Error:

Insufficient host memory for plotting!

RAM: Total=16.0 GiB, Available=8.2 GiB
Plotter requirement: 4.0 GiB x1 (escalation)
Writer requirement: 3.0 GiB x1 (escalation)
GPU requirement: 2.0 GiB
TOTAL requirement: 9.0 GiB

Solutions:

  1. Close other applications to free RAM
  2. Reduce compression level: -x 1 instead of -x 4
  3. Set memory limit: -m 8GiB
  4. Reduce escalate: Use default (1) instead of higher values
  5. Disable GPU: Plot CPU-only to free VRAM
  6. Plot fewer disks simultaneously

Insufficient Disk Space

Error:

Insufficient disk space, MiB_required=1048576, MiB_available=524288, path=/mnt/disk1

Solutions:

  • Free up disk space
  • Reduce warp count: -w 500 instead of -w 1024
  • Plot to different disk: -p /mnt/disk2

Invalid Seed Format

Error:

Invalid seed length: expected 64 hex characters, got 32

Solution:

  • Ensure seed is exactly 64 hexadecimal characters (0-9, a-f, A-F)
  • Check for spaces or special characters
  • Extract seed from plot filename (64-character section)

Permission Errors

Error:

Permission denied: /path/to/plots

Solutions:

  • Ensure write permissions: chmod 755 /path/to/plots
  • Check directory exists: mkdir -p /path/to/plots
  • Run with appropriate user permissions (avoid root if possible)

OpenCL Issues

No Platforms Found

Error:

No OpenCL platforms found.
OpenCL runtime is installed but no compatible GPU detected.

Solutions:

  1. Install OpenCL runtime for your GPU vendor
  2. Check GPU is detected: lspci | grep -i vga (Linux)
  3. Update GPU drivers
  4. Verify with clinfo: clinfo (if installed)

Platform/Device Not Found

Error:

OpenCL platform 2 does not exist

Solutions:

  • Run pocx_plotter -o to list available platforms/devices
  • Use correct platform:device indices from the output
  • Platform/device numbering starts at 0

Insufficient GPU Memory

Error:

Not enough GPU memory. Required: 4096 MiB, Available: 2048 MiB

Solutions:

  1. Reduce core count: -g 0:0:1024 instead of -g 0:0:4096
  2. Enable zero-copy (integrated GPUs only): -z
  3. Use CPU plotting instead

Kernel Compilation Failed

Error:

Failed to build OpenCL kernel: ...

Solutions:

  • Update GPU drivers to latest version
  • Check OpenCL version compatibility (need 1.2+)
  • Try different GPU if available
  • Fall back to CPU plotting

Performance Issues

Slow Plotting Speed

Symptoms:

  • Much slower than expected
  • Progress stalls frequently

Diagnostics:

  1. Check CPU usage: Should be near 100% per thread
  2. Check disk I/O: iostat -x 5 (Linux) or Task Manager (Windows)
  3. Check SIMD detection: Look for AVX2/AVX in startup output

Solutions:

  1. Verify SIMD enabled: Should see AVX2 or better
  2. Close background applications
  3. Check disk health: Failing HDDs slow down dramatically
  4. Try Direct I/O: Remove -d flag if you disabled it
  5. Increase buffer multiplier: -e 2
  6. Use faster storage: SSD instead of HDD

System Unresponsive

Symptoms:

  • Mouse/keyboard lag
  • Other applications slow

Solutions:

  1. Reduce CPU threads: -c 12 (instead of all 16 cores)
  2. Enable low priority: -l
  3. Limit memory: -m 8GiB

GPU Not Utilized

Symptoms:

  • GPU usage at 0% (check with nvidia-smi or similar)
  • Plotting speed same as CPU-only

Solutions:

  1. Verify OpenCL build: Rebuild with --features opencl
  2. Check GPU parameter: Ensure -g flag is correct
  3. Increase core count: Try higher values
  4. Check GPU power management: Disable power saving

File Corruption

Plot File Verification Fails

Symptom:

Verification failed: Hash mismatch at nonce 12345

Solutions:

  1. Check disk health: Run smartctl -a /dev/sdX (Linux) or CrystalDiskInfo (Windows)
  2. Re-plot the file: Delete and recreate
  3. Try different disk: Hardware may be failing
  4. Disable overclocking: If CPU/RAM is overclocked

Resume Issues

Cannot Resume Plot

Error:

Resume seed does not match plot file

Solutions:

  • Ensure you're using the exact seed from the filename (64 hex characters)
  • Verify address, warps, and compression match original
  • Must use -n 1 (single plot file)

FAQ

General Questions

Can I plot to network drives?

Yes, but with caveats:

  • Disable Direct I/O: -d
  • Performance will be limited by network speed
  • NFS/SMB may have compatibility issues
  • Wired connections strongly recommended

What compression level should I use?

Recommendation: Use X1 (default) unless:

  • Network requires higher compression
  • You have abundant RAM and CPU resources
  • You want to participate in higher-difficulty mining

Higher compression (X2, X4, X8) requires exponentially more:

  • Computation time
  • Memory usage
  • Power consumption

Can I stop and resume plotting?

Yes, if planned in advance:

  1. Note the seed from the filename during plotting
  2. If interrupted, use the same seed with -s flag
  3. Must use identical parameters (address, warps, compression)
  4. Only works with single file (-n 1)

No automatic resume: You must manually provide the seed.

Can I plot multiple files simultaneously?

Yes, in two ways:

  1. Multiple directories (parallel):

    pocx_plotter -i <addr> -p /disk1 -p /disk2 -p /disk3 -w 1000

  2. Multiple processes (manual):

    pocx_plotter -i <addr> -p /disk1 -w 1000 &
pocx_plotter -i <addr> -p /disk2 -w 1000 &

Watch total memory usage to avoid OOM.

Do I need to re-plot for different blockchains?

It depends on whether the blockchains use the same address payload:

  • Same payload → No replotting needed: If networks derive the same 20-byte payload from your address, the same plot files work
  • Different payload → Replotting required: If networks construct addresses differently, plots are not compatible

PoCX plot files store only the 20-byte address payload (network-independent format), but compatibility between chains depends on address derivation schemes.

Technical Questions

Why is my GPU slower than expected?

Common causes:

  1. Thermal throttling: GPU overheating, clean dust/improve cooling
  2. Power limit: GPU not receiving enough power
  3. Wrong configuration: Try different core counts
  4. CPU bottleneck: Try GPU-only mode (no -c flag)
  5. Driver issues: Update to latest GPU drivers

What's the difference between warps and nonces?

  • 1 Nonce = 4,096 scoops = 262,144 bytes = 256 KiB
  • 1 Warp = 4,096 nonces = 1,073,741,824 bytes = 1 GiB exactly

Conversion: 1 warp = 4,096 nonces

Can I verify my plots?

Yes, use pocx_verifier:

# Full verification
pocx_verifier check -f plot.pocx -m complete

# Quick check (sample 100 random nonces)
pocx_verifier check -f plot.pocx -m random

How much power does plotting consume?

CPU plotting:

  • Modern desktop: 100-200W
  • High-end workstation: 200-400W

GPU plotting:

  • Add GPU TDP (e.g., RTX 3080 = +320W)
  • Total: 400-700W for high-end systems

Cost: Electricity costs vary by location. Calculate:

kWh = (Watts × Hours) / 1000
Cost = kWh × Rate_per_kWh

Example: 300W for 100 hours at $0.12/kWh:

kWh = (300 × 100) / 1000 = 30 kWh
Cost = 30 × $0.12 = $3.60

Can I overclock for faster plotting?

Yes, but with caution:

  • CPU overclock: Can improve performance 5-15%
  • GPU overclock: Can improve GPU plotting 10-20%
  • RAM overclock: Minimal benefit (< 5%)

Risks:

  • System instability
  • Data corruption (validate plots after)
  • Increased power consumption
  • Reduced hardware lifespan

Recommendation: Only overclock if experienced. Plot verification is essential.

Additional Resources

Document Version: 1.0.0 Last Updated: 2025-10-13 Maintained by: Proof of Capacity Consortium

Clone this wiki locally