y-cruncher Cheat-Sheet

y-cruncher Command-Line Cheatsheet with Examples

General Usage

y-cruncher [startup options] [option] [extra parameters]

Examples

• Run a Pi benchmark (500 million digits):

  y-cruncher skip-warnings bench 500m
  

• Compute log(2) to 100 billion digits using 60GB RAM and 4 drives in RAID 0:

  y-cruncher custom log:2 -dec:100b -mode:swap -M:60g -swap:raid0 g:/ h:/ i:/ j:/
  

• Run a configuration file:

  y-cruncher config config-name.ini
  

---

Startup Parameters

1. Pause at End of Computation:

   pause:{-2 | -1 | 0 | 1}
   

   • pause:1 - Always pause.
   • pause:-2 - Never pause.
   • Example:
     This command runs a benchmark for 1 billion digits of Pi and pauses at the end.
     

     y-cruncher pause:1 bench 1b
     

2. Skip Warnings:

   skip-warnings
   

   • Example:
     This command runs a Pi benchmark for 250 million digits without displaying warnings.
     

     y-cruncher skip-warnings bench 250m
     

3. Set Console Height (Windows only):

   height:{height in lines}
   

   • Example:
     This sets the console height to 50 lines while running a benchmark for 100 million digits.
     

     y-cruncher height:50 bench 100m
     

4. Priority:

   priority:{value}
   

   • Windows: 2 (Low) to 3 (Realtime)
   • Linux: 1 (Min) to 0 (Max)
   • Example:
     This runs a Pi benchmark for 1 billion digits with the highest priority (realtime) on Windows.
     

     y-cruncher priority:3 bench 1b
     

5. Console Colors:

   colors:{0 | 1}
   

   • Example:
     This command runs a benchmark for 50 million digits with colored output enabled.
     

     y-cruncher colors:1 bench 50m
     

6. Personally Identifiable Information:

   PII:{0 | 1 | -1}
   

   • Example:
     This command runs a Pi benchmark for 100 million digits and suppresses any PII from the logs.
     

     y-cruncher PII:0 bench 100m
     

---

Features & Options

1. Benchmark Pi:

   y-cruncher bench {size} [-TD:{tasks}] [-PF:{framework}] [-MA:{allocator}]
   

   • Sizes: 25m, 50m, 100m... 1t, 2.5t, 1M, 2M... 128G
   • Example:
     This runs a Pi benchmark for 500 million digits using 8 tasks, the TBB parallel framework, and JEMalloc memory allocator.
     

     y-cruncher bench 500m -TD:8 -PF:TBB -MA:JEMalloc
     

2. Benchmark Pi BBP:

   y-cruncher bench-bbp {size}
   

   • Sizes: 100m, 1b, 10b... 1q
   • Example:
     This runs a BBP benchmark for Pi to 1 billion digits.
     

     y-cruncher bench-bbp 1b
     

3. Component Stress Tester:

   y-cruncher stress [-M:{memory}] [-D:{duration}] [-TL:{time limit}] [algorithm]
   

   • Example:
     This stress tests the system's FFT component using 32GB of memory for 1 hour.
     

     y-cruncher stress -M:32g -D:1h FFT
     

4. I/O Benchmark:

   y-cruncher benchio [-M:{memory}] [-TD:{tasks}] [-minIO:{Min I/O Size}]
   

   • Example:
     This runs an I/O benchmark using 16GB of memory, 4 tasks, and a minimum I/O size of 512MB.
     

     y-cruncher benchio -M:16g -TD:4 -minIO:512m
     

5. BBP Digit Extractor for Pi:

   y-cruncher bbp -hex:{offset} [-digits:{count}] [-TD:{tasks}] [-algorithm:{algorithm}]
   

   • Example:
     This extracts 1000 digits of Pi starting from the 1 billionth digit using 4 tasks and algorithm 2.
     

     y-cruncher bbp -hex:1000000000 -digits:1000 -TD:4 -algorithm:2
     

6. Custom Compute:

   y-cruncher custom {constant[:param]} [-algorithm:{#}] [-dec:{digits}] [-hex:{digits}] [-o {output path}] [-verify:{0|1}] [-mode:{mode}] [-TD:{tasks}]
   

   • Example:
     This computes the square root of 2 to 10 billion decimal digits, outputs to
     sqrt2_10b.txt, verifies the computation, and uses 8 tasks in swap mode.

     y-cruncher custom sqrt:2 -dec:10b -o sqrt2_10b.txt -verify:1 -mode:swap -TD:8
     

---

Common Sub-Parameters

1. Output Path:

   -o {path}
   

   • Example:
     This computes Pi to 1 billion digits and outputs the result to
     pi_1b.txt.

     y-cruncher custom pi -dec:1b -o pi_1b.txt
     

2. Digit Output:

   -od:{0 | 1}
   

   • Example:
     This computes Pi to 500 million digits and outputs the digits directly.
     

     y-cruncher custom pi -dec:500m -od:1
     

3. Task Decomposition:

   -TD:{tasks}
   

   • Example:
     This computes log(2) to 100 billion digits using 16 tasks.
     

     y-cruncher custom log:2 -dec:100b -TD:16
     

4. Parallel Framework:

   -PF:{framework}
   

   • Example:
     This runs a benchmark for 1 billion digits of Pi using the OpenMP parallel framework.
     

     y-cruncher bench 1b -PF:OpenMP
     

5. Memory:

   -M:{memory bytes}
   

   • Example:
     This computes Pi to 1 trillion digits using 128GB of memory.
     

     y-cruncher custom pi -dec:1t -M:128g
     

6. Memory Allocator:

   -MA:{allocator}
   

   • Example:
     This runs a Pi benchmark for 2.5 trillion digits using the TCMalloc memory allocator.
     

     y-cruncher bench 2.5t -MA:TCMalloc
     

7. Min I/O Bytes:

   -minIO:{bytes}
   

   • Example:
     This runs an I/O benchmark using 64GB of memory with a minimum I/O size of 1GB.
     

     y-cruncher benchio -M:64g -minIO:1g
     

8. Swap Mode Configuration:

   -swap:{mode} [paths]
   

   • Example:
     This computes the square root of 2 to 100 billion digits using RAID 0 swap mode across multiple drives.
     

     y-cruncher custom sqrt:2 -dec:100b -swap:raid0 d:/ e:/ f:/ g:/
     

---

This updated cheatsheet includes examples to illustrate each command and option, making it easier to understand and apply y-cruncher's functionalities in various scenarios.