CoreCycler config for Alder Lake

# Config for Alder Lake by neurokirurgi
# Save as config.ini in the CoreCycler main folder, replacing the old config
# This config is tested to work on CoreCycler v0.8.2.4 dated May 11, 2021.
# Link to CoreCycler GitHub page: https://github.com/sp00n/corecycler

# READ THIS!
# Since we can't switch between P-cores and E-cores without the script returning an error,
# we need to set CoreCycler to ignore the E-cores.
# This config file is preconfigured for an 8P+8E Alder Lake CPU. The setting is located on row 109.
# If you have a 12600K(F), set coresToIgnore = 6, 7, 8, 9
# If you have a 12700K(F), set coresToIgnore = 8, 9, 10, 11
# If you have a 12900K(F), set coresToIgnore = 8, 9, 10, 11, 12, 13, 14, 15

# General settings
[General]

# The program to perform the actual stress test
# The following programs are available:
# - PRIME95
# - AIDA64
# - YCRUNCHER
# You can change the test mode for each program in the relavant [sections] below.
# Note: For AIDA64, you need to manually download and extract the portable ENGINEER version and put it
#       in the /test_programs/aida64/ folder
# Note: AIDA64 is somewhat sketchy as well
# Default: PRIME95
stressTestProgram = PRIME95

# Set the runtime per core
# You can use a value in seconds or use 'h' for hours, 'm' for minutes and 's' for seconds
# Examples: 360 = 360 seconds
#           1h4m = 1 hour, 4 minutes
#           1.5m = 1.5 minutes = 90 seconds
#
# You can also set it to "auto", in which case it will perform one full run of all the FFT sizes in the selected
# Prime95 preset for each core, and when that is finished, it continues to the next core and starts again
# For Aida64 and y-Cruncher, the "auto" setting will default to 10 Minutes per core
#
# Below are some examples of the runtime for one iteration for the various tests on my 5900X with one thread
# The first iteration is also usually the fastest one
# Selecting two threads usually takes *much* longer than one thread for one iteration in Prime95
# - Prime95 "Smallest":     4K to   21K - [SSE] ~3-4 Minutes   <|> [AVX] ~8-9 Minutes    <|> [AVX2] ~8-10 Minutes
# - Prime95 "Small":       36K to  248K - [SSE] ~4-6 Minutes   <|> [AVX] ~14-19 Minutes  <|> [AVX2] ~14-19 Minutes
# - Prime95 "Large":      426K to 8192K - [SSE] ~18-22 Minutes <|> [AVX] ~37-44 Minutes  <|> [AVX2] ~38-51 Minutes
# - Prime95 "Huge":      8960K to   MAX - [SSE] ~13-19 Minutes <|> [AVX] ~27-40 Minutes  <|> [AVX2] ~33-51 Minutes
# - Prime95 "All":          4K to   MAX - [SSE] ~40-65 Minutes <|> [AVX] ~92-131 Minutes <|> [AVX2] ~102-159 Minutes
# - Prime95 "Moderate":  1344K to 4096K - [SSE] ~7-15 Minutes  <|> [AVX] ~17-30 Minutes  <|> [AVX2] ~17-33 Minutes
# - Prime95 "Heavy":        4K to 1344K - [SSE] ~15-28 Minutes <|> [AVX] ~43-68 Minutes  <|> [AVX2] ~47-73 Minutes
# - Prime95 "HeavyShort":   4K to  160K - [SSE] ~6-8 Minutes   <|> [AVX] ~22-24 Minutes  <|> [AVX2] ~23-25 Minutes
# - y-Cruncher: ~10 Minutes
# Default: 6m
runtimePerCore = 6m

# Periodically suspend the stress test program
# This can simulate load changes / switches to idle and back
# Setting this to 1 will periodically suspend the stress test program, wait for a bit, and then resume it
# You should see the CPU load and clock speed drop significantly while the program is suspended and rise back up again
# Note: This will increase the runtime of the various stress tests as seen in the "runtimePerCore" setting by roughly 10%
# Default: 1
suspendPeriodically = 1

# The test order of the cores
# Available modes:
# Default:    On CPUs with more than 8 physical cores: 'Alternate'. Otherwise 'Random'
# Alternate:  Alternate between the 1st core on CCD1, then 1st on CCD2, then 2nd on CCD1, then 2nd on CCD2, etc.
#             This should distribute the heat more evenly and possibly allow for higher clocks on CPUs with 2 CCDs
# Random:     A random order
# Sequential: Cycle through the cores in numerical order
#
# You can also define your own testing order by entering a list of comma separated values.
# The list will be processed as provided, which means you can test the same core multiple times per iteration.
# Do note however that the "coresToIgnore" setting still takes precedence over any core listed here.
# The enumeration of cores starts with 0
# Example: 5, 4, 0, 5, 5, 7, 2
#
# Default: Default
coreTestOrder = Random

# Skip a core that has thrown an error on the following iterations
# If set to 0, this will test a core on the next iterations even if has thrown an error before
# Default: 1
skipCoreOnError = 1

# Stop the whole testing process if an error occurred
# If set to 0 (default), the stress test programm will be restarted when an error
# occurs and the core that caused the error will be skipped on the next iteration
# Default: 0
stopOnError = 0

# The number of threads to use for testing
# You can only choose between 1 and 2
# If Hyperthreading / SMT is disabled, this will automatically be set to 1
# Currently there's no automatic way to determine which core has thrown an error
# Setting this to 1 causes higher boost clock speed (due to less heat)
# Default: 1
# Maximum: 2
numberOfThreads = 1

# The max number of iterations
# High values are basically unlimited
# Default: 10000
maxIterations = 10000

# Ignore certain cores
# Comma separated list of cores that will not be tested
# The enumeration of cores starts with 0
# Example: coresToIgnore = 0, 1, 2
# Default: (empty)
coresToIgnore = 8, 9, 10, 11, 12, 13, 14, 15

# Restart the stress test process when a new core is selected
# This means each core will perform the same sequence of tests during the stress test
# Note: The monitor doesn't seem to turn off when this setting is enabled
#
# Important note:
# One disadvantage of this setting is that it has the potential to limit the amount of tests that the stress test program
# can run.
# In Prime95 for example, each FFT size will run for roughly 1 minute (except for very small ones), so if you want to make
# sure that Prime95 runs all of the available FFT sizes for a setting, you'll have to extend the "runtimePerCore" setting
# from the default value to something higher.
# For example the "Huge"/SSE preset has 19 FFT entries, and tests on my 5900X showed that it roughly takes 13-19 Minutes
# until all FFT sizes have been tested. The "Large"/SSE seems to take between 18 and 22 Minutes.
# I've included the measured times in the comment for the "runtimePerCore" setting above.
#
# If this setting is disabled, there's a relatively high chance that each core will eventually pass through all of the
# FFT sizes since Prime95 doesn't stop between the cores and so it evens out after time.
#
# Default: 0
restartTestProgramForEachCore = 0

# Set a delay between the cores
# If the "restartTestProgramForEachCore" flag is set, this setting will define the amount of seconds between the end of the
# run of one core and the start of another
# If "restartTestProgramForEachCore" is 0, this setting has no effect
# Default: 15
delayBetweenCores = 15



# Prime95 specific settings
[Prime95]

# The test modes for Prime95
# SSE:    lightest load on the processor, lowest temperatures, highest boost clock
# AVX:    medium load on the processor, medium temperatures, medium boost clock
# AVX2:   heavy load on the processor, highest temperatures, lowest boost clock
# CUSTOM: you can define your own settings for Prime. See the "customs" section further below
# Default: SSE
mode = SSE

# The FFT size preset to test for Prime95
# These are basically the presets as present in Prime95, plus an additional few
# Note: If "mode" is set to "CUSTOM", this setting will be ignored
# Smallest:     4K to   21K - Prime95 preset: "tests L1/L2 caches, high power/heat/CPU stress"
# Small:       36K to  248K - Prime95 preset: "tests L1/L2/L3 caches, maximum power/heat/CPU stress"
# Large:      426K to 8192K - Prime95 preset: "stresses memory controller and RAM" (although dedicated memory stress testing is disabled here by default!)
# Huge:      8960K to   MAX - anything beginning at 8960K up to the highest FFT size (32768K for SSE/AVX, 51200K for AVX2)
# All:          4K to   MAX - 4K to up to the highest FFT size (32768K for SSE/AVX, 51200K for AVX2)
# Moderate:  1344K to 4096K - special preset, recommended in the "Curve Optimizer Guide Ryzen 5000"
# Heavy:        4K to 1344K - special preset, recommended in the "Curve Optimizer Guide Ryzen 5000"
# HeavyShort:   4K to  160K - special preset, recommended in the "Curve Optimizer Guide Ryzen 5000"
#
# You can also define you own range by entering two FFT sizes joined by a hyphen, e.g 36-1344
#
# Default: Huge
FFTSize = Huge



# Aida64 specific settings
[Aida64]

# The test modes for Aida64
# Note: "RAM" consumes basically all of the available memory and makes the computer pretty slow
#       You can change the amount of RAM being used / tested with the "maxMempory" setting below
# CACHE: Starts Aida64 with the "Cache" stress test
# CPU:   Starts Aida64 with the "CPU" stress test
# FPU:   Starts Aida64 with the "FPU" stress test
# RAM:   Starts Aida64 with the "Memory" stress test
# You can also combine multiple stress tests like so: CACHE,CPU,FPU
# Default: CACHE
mode = CACHE

# Use AVX for Aida64
# This enables or disables the usage of AVX instructions during Aida64's stress tests
# Default: 0
useAVX = 0

# The maximum memory allocation for Aida64
# Sets the maximum memory usage during the "RAM" stress test in percent
# Note: Setting this too high can cause your Windows to slow down to a crawl!
# Default: 90
maxMemory = 90



# y-Cruncher specific settings
[yCruncher]

# The test modes for y-Cruncher
# See the \test_programs\y-cruncher\Binaries\Tuning.txt file for a detailed explanation
# "00-x86"          - 86/IA-32 since Pentium (BSWAP, CMPXCHG, CPUID, RDTSC, possibly others...)
# "04-P4P"          - SSE, SSE2, SSE3
# "05-A64 ~ Kasumi" - x64, SSE, SSE2, SSE3
# "08-NHM ~ Ushio"  - x64, SSE, SSE2, SSE3, SSSE3, SSE4.1
# "11-SNB ~ Hina"   - x64, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX
# "13-HSW ~ Airi"   - x64, ABM, BMI1, BMI2, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, FMA3, AVX2
# "14-BDW ~ Kurumi" - x64, ABM, BMI1, BMI2, ADX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, FMA3, AVX2
# "17-ZN1 ~ Yukina" - x64, ABM, BMI1, BMI2, ADX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, FMA3, AVX2
# "19-ZN2 ~ Kagari" - x64, ABM, BMI1, BMI2, ADX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, FMA3, AVX2
#
# The following settings would be available as well, but they don't run on Ryzen CPUs!
# "11-BD1 ~ Miyu"   - x64, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, ABM, FMA4, XOP
# "17-SKX ~ Kotori" - x64, ABM, BMI1, BMI2, ADX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, FMA3, AVX2 AVX512-(F/CD/VL/BW/DQ)
# "18-CNL ~ Shinoa" - x64, ABM, BMI1, BMI2, ADX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, FMA3, AVX2 AVX512-(F/CD/VL/BW/DQ/IFMA/VBMI)
#
# "00-x86" should produce the highest boost clock on most tests
# "19-ZN2 ~ Kagari" is optimized for Zen2/3, but produces more heat and a lower boost clock on most tests
# Default: 00-x86
mode = 00-x86



# Log specific settings
[Logging]

# The name of the log file
# The "mode" parameter, the selected stress test program and test mode, as well as the start date & time will be
# added to the name, with a .log file ending
# Default: CoreCycler
name = CoreCycler

# Set the log level
# 0: Do not log or display additional information
# 1: Write additional information to the log file (verbose)
# 2: Write even more information to the log file (debug)
# 3: Also display the verbose messages in the terminal
# 4: Also display he debug messages in the terminal
# Default: 2
logLevel = 2

# Custom settings for Prime95
[Custom]

# This needs to be set to 1 for AVX mode
# (and also if you want to set AVX2 below)
CpuSupportsAVX = 0

# This needs to be set to 1 for AVX2 mode
CpuSupportsAVX2 = 0

# This also needs to be set to 1 for AVX2 mode on Ryzen
CpuSupportsFMA3 = 0

# The minimum FFT size to test
# Value for "Smallest FFT":   4
# Value for "Small FFT":     36
# Value for "Large FFT":    426
MinTortureFFT = 4

# The maximum FFT size to test
# Value for "Smallest FFT":   21
# Value for "Small FFT":     248
# Value for "Large FFT":    8192
MaxTortureFFT = 8192

# The amount of memory to use in MB
# 0 = In-Place
TortureMem = 0

# The max amount of minutes for each FFT size during the stress test
# Note: It may be much less than one minute, basically it seems to be "one run or one minute, whichever is less"
TortureTime = 1