Softpedia >Windows >Science / CAD >y-cruncher >  Changelog

y-cruncher Changelog

What's new in y-cruncher 0.8.4 Build 9538

Feb 22, 2024
  • Fixed a crash that can happen when using more than 64 threads.

New in y-cruncher 0.8.4 Build 9537 (Feb 22, 2024)

  • General Changes:
  • The limit of y-cruncher has been (tentatively) increased from 1 x 1015 to 108 x 1015 decimal digits. Computations above 200 trillion digits will still require developer authorization for now. The Euler-Mascheroni Constant has a lower limit of around 31 x 1015 digits due to the current implementation overflowing a 64-bit integer at a lower size.
  • The swap mode radix conversion has been completely rewritten and now supports checkpointing.
  • Replaced the "11-BD1" binary with "12-BD2" with the following changes:
  • 12-BD2 uses FMA3 instead of FMA4.
  • Optimizations for 1st gen AMD Bulldozer are therefore dropped.
  • Change of compiler from MSVC to ICC for Windows.
  • Validation files now include more samples of digits.
  • Validation files now records statistics for hexadecimal digits even if they are disabled for output.
  • Math Changes:
  • Log(x) for both the built-in constant and the custom formula function will now special case for powers of 2, 3, and 5 using these new (and faster) formulas by Jorge Zuniga.
  • Log(2) - Zuniga (2024-i)
  • Log(2) - Zuniga (2024-ii)
  • Log(3) - Zuniga (2024-i)
  • Log(5) - Zuniga (2024-i)
  • The BBP digit extractor now supports Huvent's BBP formula which is slightly faster than Bellard's.
  • Custom Formula Changes:
  • New Functions:
  • Square(x)
  • Reciprocal(x)
  • Log2
  • Exp(x)
  • All hyperbolic trig functions.
  • All inverse hyperbolic trig functions.
  • Divide(x, y) will now special case for x being a small integer. It is no longer necessary to use Power(x, -1) and LinearCombination() to get the same effect performance-wise.
  • ArcCoth(x) now supports non-integer inputs.
  • Power(x, y) now supports non-integer powers.
  • Invsqrt(x) of a large number and all dependent functions are slightly faster. (affects Sqrt(x), AGM(x), and Log(x))
  • All functions that internally require a constant (such as Pi, e, or log(2)) can optionally take them as parameters to avoid recomputing them. This deprecates Log-AGM since the ability to specify Pi and log(2) has been added to Log(x) itself.
  • As a result of these new functions, there are a lot of new formulas as well as modifications to existing ones.
  • Bug Fixes:
  • Fixed the Amdahl's Law + Zen4 Hazard debacle affecting swap mode computations on machines with many cores.
  • Carryout parallelization for the VT3 and N63 algorithms has been fixed and re-enabled.
  • Fixed a bug that may cause extremely large swap mode multiplications to pick suboptimal parameters.

New in y-cruncher 0.8.3 Build 9533 (Feb 14, 2024)

  • Bug Fixes:
  • Fixed a serious bug that may cause large multiplications larger than 29 trillion digits to fail.
  • Fixed an issue where a computation error in swap mode may crash the program before it can print out the error.
  • Fixed a bug in the 32-bit binaries that may cause large swap mode computations to fail. The root cause is an integer overflow of size_t.
  • Fixed HWBOT submitter not recognizing v0.8.3 for launching benchmarks.
  • The Linux binaries now have the correct version of libtbb.
  • Fixed config load/saving not working for the swap multiply tester.

New in y-cruncher 0.8.3 Build 9532 (Dec 8, 2023)

  • Fixed an issue where the config files would not properly handle escape characters. This prevented the use of NTFS mount points for file paths to exceed the 26 drive letter limit.

New in y-cruncher 0.8.3 Build 9531 (Dec 6, 2023)

  • Fixed an issue that prevented the program from working on Windows 7.
  • Fixed a potentially serious issue that may cause incorrect computation*.
  • This is caused by a bug in the parallel carry propagation for the VT3 and N63 algorithms. While the issue has never appeared in actual computations or even internal regression tests, it was found while refactoring the relevant code for v0.8.4.

New in y-cruncher 0.8.3 Build 9530 (Dec 3, 2023)

  • Bug Fixes:
  • Untested fix for an issue in Linux where thread-affinities may not always work.
  • Fixed an issue where base conversion can fail for certain "short" numbers.

New in y-cruncher 0.8.2 Build 9524 (Oct 14, 2023)

  • Fixed a serious bug in swap mode where a large multiplication with a lot of memory may fail.

New in y-cruncher 0.8.2 Build 9523 (Sep 22, 2023)

  • Fixed detection of newer instructions sets like APX and AVX10.
  • This bug has no functional effect on the program since y-cruncher does not use these newer instruction sets yet.

New in y-cruncher 0.8.2 Build 9522 (Sep 4, 2023)

  • Features:
  • Removed the 20-ZN3 ~ Yuzuki binary. Performance is poor due to inadequate hardware for tuning. (I need a Ryzen 9 5950X to do this.)
  • Removed the N64 and C17 algorithms. N64 has been superceded by its rewrite, the "N63". C17 has been superceded by VT3.
  • Added a new algorithm "N63" which is the ground-up rewrite of the 64-bit NTT (N64).
  • VT3 and N63 now support swap mode. Thus swap mode computations now use VT3 and N63 instead of VST, C17, and N64.
  • Swap mode now has a new framework that uses ram as far-memory. It's primarily for testing purposes, but can probably be used for more efficient computations on systems with HBM. (run the program in HBM, but use ram as disk/far-memory)
  • The swap multiply tester now supports config files.
  • The command line option for specifying swap mode paths has different implementations:
  • "raid0" will use the Disk Raid 0 framework.
  • "raid3" will use the Legacy Raid 0+3 framework.
  • "ram" will use Ram Drive framework.
  • In the past, it always used the Raid 0+3 framework which is inefficient and has been deprecated for a while.

New in y-cruncher 0.8.1 Build 9317 (Jul 11, 2023)

  • Changes:
  • Removed the N32 and Hybrid NTT algorithms. Old binaries will slow down from this.
  • Added VT3, a new implementation of the VST algorithm. New binaries will be faster.

New in y-cruncher 0.7.10 Build 9513 (Sep 1, 2022)

  • Added 22-ZN4, a new binary optimized for AMD Zen4 with AVX512.

New in y-cruncher 0.7.9 Build 9510 (Jun 19, 2022)

  • Fixed the SFT stress-test not being invokable from the command line.
  • Fixed config saving not working.
  • Computation limit has been increased to 200 trillion digits.
  • Spot-check files have been updated with the latest records.
  • Added a new custom formula for Catalan's constant by Jorge Zuniga.
  • 20-ZN3 is no longer automatically selected due to unexpectedly poor tuning.

New in y-cruncher 0.7.9 Build 9509 (Mar 14, 2022)

  • Added 20-ZN3, a new binary tuned for AMD Zen 3. Depending on your system and configuration, it may or may not actually be faster than 18-ZN2. You will have to experiment.
  • The 18-CNL binary has now been retuned for Intel Tiger Lake. It will still run on Cannon Lake since it doesn't use any new instructions.
  • The menu and configurations for digit output have been revamped to allow for more output formats in the future. For now, the only new setting is that you can enable/disable the use of raw I/O for digit output.
  • Fixed an issue in an upcoming version of Windows where multiple processor groups can be assigned to the same NUMA node.
  • Removed the 00-x86 binary as it is well outdated and bloating the download sizes.
  • All binaries have been retuned to reduce memory footprint at the cost of more computation. Performance changes can be in either direction (better or worse).
  • Compilers and libraries have been fast-forward by 2 years since this project went on hiatus.

New in y-cruncher 0.7.8 Build 9507 (Sep 15, 2020)

  • New Features:
  • The swap multiply tester now shows how many data passes are needed to perform the forward FFT.
  • The stress tester now allows a global time limit as opposed to running endlessly.
  • Fixes:
  • Fixed another BufferTooSmallException in Custom Formulas.

New in y-cruncher 0.7.8 Build 9506 (Jun 8, 2020)

  • New Features:
  • 19-ZN2: A new binary optimized for AMD Zen 2 processors.
  • Fixes:
  • Fixed a buffer overrun in the Linux versions with the numa-interleave allocators.
  • Fixed an issue in custom formulas that may cause a BufferTooSmallException.
  • Improved detection for HPET on Windows for HWBOT.

New in y-cruncher 0.7.7 Build 9501 (Apr 23, 2019)

  • P5 - Fixed an issue where errors while creating, opening, or renaming a swap file won't print out the internal error message.
  • P3 - Fixed an incorrect entry in the digit spot check file for Log(10).
  • P3 - Fixed a possible bug in the memory calculations for certain binaries.

New in y-cruncher 0.7.7 Build 9500 (Mar 28, 2019)

  • Fixed an issue where Zeta(3) - Wedeniwski would fail to resume from a checkpoint.
  • Improved error message in Linux when the disk is full.
  • Fixed some issues in the custom formulas.

New in y-cruncher 0.7.7 Build 9499 (Mar 11, 2019)

  • Fixes:
  • Removed an outdated message about a million digits being the minimum.
  • Fixed an issue with the RAID3 after marking a drive as failed.
  • Fixed an issue where the program cannot immediately recover from a drive failure in RAID3 while renaming checkpoint files.
  • Fixed some incorrect error messages for certain file IO errors.
  • Fixed a crash in the I/O benchmark when using a large task decomposition for some situations.
  • Fixed an issue in the BBP digit extractor with a very large number of threads.
  • Fixed some issues with loading invalid configuration files.
  • Fixed a corner-case bug for some Newton's Method iterations.
  • Fixed a minor bug with invalid input handling for command line arguments.
  • Fixed a crash in Swap Mode for some custom formulas.
  • The year for the Chudnovsky formula has been changed to 1988. The original year (1989) was the wrong year.
  • Fixed a typo in Ramanujan's formula for Pi.
  • Fixed an issue where some swap mode computations over-estimate their required disk usage.
  • Fixed an issue where some custom formula functions use more disk than they are supposed to in Swap Mode.
  • Other:
  • Added support for a new syntax for the custom formula Scope function that preserves ordering through JSON serialization.

New in y-cruncher 0.7.7 Build 9498 (Mar 11, 2019)

  • Fixes:
  • Fixed a regression in v0.7.7.9497 where one of the many bugfixes triggered a compiler optimizer bug in VS2015 that would sometimes cause the relevant binaries to incorrectly calculate memory sizes. This is significant because it had a small potential to produce a computation plan that could not be finished. Bugs like this are normally caught during the extensive QA testing phase prior to a feature release. But these tests are not rerun for patch releases.
  • Fixed a crash in some low memory situations involving the swap files.
  • Fixed some issues with the RAID-3 functionality.
  • When the program crashes on mulitple threads simultaneously, the error and mini-dump messages are no longer overlapping.
  • Fixed multiple minor UI bugs.
  • The time limit in the stress-tester has been capped to 1 million seconds.
  • Fixed an alignment issue in some internal functions.
  • Fixed a couple minor UI bugs in the core selector menu of the stress tester.
  • Fixed a bug in the I/O benchmark when the bytes/seek is greater than the working memory.
  • Fixed a minor UI bug in the Digit Viewer.
  • Fixed an issue with running a stress-test from a configuration file with invalid core numbers.
  • Fixed an issue where custom formula labels weren't properly being sanitized.

New in y-cruncher 0.7.7 Build 9497 (Feb 16, 2019)

  • Fixed an issue where a short number can error the program. This is only possible to hit from the custom formulas.
  • Fixed an out-of-date warning for extremely slow series.
  • Fixed a bug in the Euler-Mascheroni Constant that may cause it to display an incorrect value for the disk usage.
  • The length limit for custom formula strings now counts Unicode code points instead of UTF-8 code-units.
  • When running a swap mode computation from the command line, the "bytes/seek" parameter wouldn't auto-update when the swap configuration is set.
  • Fixed an issue where certain invalid UTF-8 sequences will cause y-cruncher to hang.
  • Fixed some more BufferTooSmallException errors in the custom formulas.
  • Fixed a spurious error in Newton Method implementations that can only be hit with custom formulas.
  • Fixed an issue with SeriesBinaryBBP for large power coefficients.
  • Fixed a bug in the RAID-3 quick configure.
  • Huge thanks to ??? for systematically trying to break the program in every way possible. He found all but one of the bugs on this list! Most of these are years old bugs that are now being exposed by the custom formulas.

New in y-cruncher 0.7.7 Build 9496 (Feb 3, 2019)

  • Removed some extraneous warnings for unusual series and extremely large computations.
  • Fixed a crash in the I/O benchmark when using a very small amount of memory.
  • Fixed a bug in the custom formulas that can cause a BufferTooSmallException.

New in y-cruncher 0.7.7 Build 9495 (Jan 25, 2019)

  • Fixes:
  • Partial work-around for system error code (1453) which may happen while writing digits at the end of a large computation on systems with very little memory.
  • Improved error message for error code 1453 to hint at possible low memory situation.
  • The Gamma(1/4) digit file should now properly decompress on non-English locales.
  • Errors when loading custom formula files are now handled more consistently.
  • Error messages from simultaneous swap file errors will not overlap as badly as before.

New in y-cruncher 0.7.7 Build 9494 (Jan 11, 2019)

  • Fixes:
  • Series polynomials of degree larger than 62 are now disallowed. Polynomials of degree 63 or higher will hang the program.
  • Certain classes of polynomials will cause y-cruncher to error or enter an infinite loop.

New in y-cruncher 0.7.7 Build 9493 (Jan 5, 2019)

  • New Features:
  • Custom Formulas: y-cruncher can now run a limited set of user-specified formulas. This allows the user to compute more than just the built-in constants. It also allows the user to implement alternative formulas for the existing constants. Sample formulas have been included in the y-cruncher downloads.
  • Catalan's Constant Algorithms: 3 new algorithms have been added for Catalan's Constant. Due to the speed of these new algorithms, the existing Lupas and Huvent formulas are now outdated. But they will remain in y-cruncher for the time being.
  • Lemniscate with AGM: The AGM algorithm has been implemented for Lemniscate. This algorithm is about 2x faster than Gauss' formula in memory. But may be slower in Swap Mode.
  • Brent-McMillan Formula with explicit n: This allows you to run the Brent-McMillan formula for the Euler-Mascheroni Constant with a manually specified n parameter. This is somewhat of a useless feature that has existed internally since 2013.
  • Digit and Validation Output Path Improvements:
  • The "-o" command line option will now be used for both the digit output as well as the validation file.
  • A new "-od" option has been added to suppress digit output. This is the new method for disabling output.
  • Added a command line option to set the priority which y-cruncher runs at.
  • When output verification is enabled, there is now an additional verification step to detect data corruption of the source data during digit output that may go undetected in previous versions.
  • The TBB parallel framework now has sub-options to tinker with.
  • There is now a command line option to override the process priority that y-cruncher will run at.
  • Removed Features:
  • ArcCoth(x) has been removed. It has become superfluous as it remains accessible from the Custom Formula feature.
  • Re-Tunings:
  • AMD Jaguar processors will now choose the 11-SNB binary instead of the 08-NHM binary.
  • The TBB parallel framework now uses slightly different library calls which may affect performance.
  • Other:
  • The file extension for configuration files has been changed to ".cfg".
  • The naming of some of the algorithms has been changed.
  • Minor speed differences due to numerous internal refactorings.
  • Non-fatal errors that occur during memory allocation are now logged to the event log.
  • More run-time warnings will now propagate to the client in Slave Mode.
  • The format for the PauseWarning message in Slave Mode has been updated.

New in y-cruncher 0.7.6 Build 9490 (Dec 3, 2018)

  • Fixes:
  • Fixed a serious bug in the Digit Viewer that may cause y-cruncher to incorrectly compress digits.
  • The stress tester will no longer crash when it fails to allocate memory.
  • Fixed some cases in Swap Mode where it will under-estimate how much storage is actually needed.

New in y-cruncher 0.7.6 Build 9489 (Nov 20, 2018)

  • Fixes:
  • Fixed a critical 32-bit integer overflow bug in the 32-bit Windows binaries. This was introduced by the 9488 patch and was caught a mere hours after it was released.

New in y-cruncher 0.7.6 Build 9488 (Nov 20, 2018)

  • Untested fix for the NUMA binding issue on 4-die Threadripper that may cause performance to drop by up to 50%.
  • Fixed some issues with really small swap mode computations.
  • Fixed some minor UI bugs in the node-interleaving frameworks for Linux.

New in y-cruncher 0.7.6 Build 9487 (Oct 15, 2018)

  • Fixes:
  • Fixed an issue that may cause very small swap mode computations with a high task decomposition to fail.
  • Fixed a crash when saving a configuration in Linux with the libnuma Node-Interleaving allocator.

New in y-cruncher 0.7.6 Build 9486 (Sep 17, 2018)

  • Fixed a bug that causes y-cruncher to crash when saving a configuration file with the Cilk Plus framework.
  • Fixed a bug that causes the program to pause when running the Euler-Mascheroni Constant in swap mode.

New in y-cruncher 0.7.6 Build 9485 (Sep 7, 2018)

  • Ugh... As expected, this is turning into one of the buggier releases...
  • Fixes:
  • Fixed a bug in the Euler-Mascheroni Constant in swap mode where it may fail to resume from a checkpoint.
  • Fixed the "-TD" option for Pi benchmarks.

New in y-cruncher 0.7.6 Build 9484 (Aug 29, 2018)

  • Fixes:
  • Fixed a bug in the Euler-Mascheroni Constant that may lead to a BufferTooSmallException.
  • New Features:
  • Added a "pause:-2" option that will also suppress pauses even in the event of an error.

New in y-cruncher 0.7.6 Build 9483 (Aug 11, 2018)

  • 18-CNL: A new binary for Cannon Lake processors that uses the AVX512 IFMA and VBMI instructions. This binary remains untuned and not fully tested. It will be updated in the future along with a proper name when the hardware becomes more readily available.
  • Digit Output Improvements:
  • Digit output can now be suppressed. This allows benchmarks to be scripted without hammering the storage device with writes.
  • When hexadecimal digits are enabled, the validation file will include the last 50 - 100 hexadecimal digits the same way that it has always included the last 50 - 100 decimal digits.
  • When hexadecimal digits are enabled, the computation will include a "hex hash". This pairs with the existing "dec hash".
  • Dec Hash = Floor(x * 10^dec) mod (2^61 - 1)
  • Hex Hash = Floor(x * 16^hex) mod (2^61 - 1)
  • The Digit Viewer has been revamped and completely rewritten:
  • It is now parallelized and better optimized.
  • Digit hashing and frequencies are now done automatically with compress/decompress streaming.
  • Digit reading is now done using raw (unbuffered) disk I/O. This is needed to avoid the Pagefile Thrash of Death on Windows.
  • More details here: https://github.com/Mysticial/DigitViewer
  • All computations will compute an additional 100 digits beyond the requested precision. These digits are not output anywhere and are kept secret from the user. Instead the SHA256 hash of digits as a 100-byte ASCII string will be written to the validation file.
  • The purpose of this is to help verify subsequent world records. When a world record is set with this feature, there will be a SHA256 hash for the next 100 digits. When the record is broken again (with any application, not just y-cruncher), the person can prove it by producing the digits that hash to this SHA256 hash.
  • Slave Mode: Preliminary support has been added for Slave Mode. This allows 3rd party applications to control y-cruncher over TCP. The main motivation is to allow for a 3rd party GUI as there are no plans to do that within y-cruncher. More details here.
  • Note that this feature is still a work in progress. Therefore it is preliminary, incomplete, and not well documented yet. The current implementation is not expected to be fully usable and will require user feedback to mature.
  • Fixes:
  • Fixed an integer overflow bug that may cause 32-bit computations of e to fail when more than 232 terms are needed.
  • The Pagefile Thrash of Death that may happen at the end of a computation has been fixed by the rewrite of the Digit Viewer.
  • Fixed an issue that may cause Swap Mode to fail on Linux when O_DIRECT isn't supported. Details here.
  • Fixed an issue that may cause the I/O Benchmark to fail with a "BufferTooSmallException".
  • Fixed a bug with the Euler-Mascheroni Constant that may cause the program to hang and consume lots of memory. This is caused by a pathological failure of the series summing logic due to the non-convergent behavior of the refinement term in the Brent-McMillan Formula.
  • Fixed a bug with the C malloc() allocator that may cause a "Buffer is misaligned." error in swap mode.
  • Optimizations:
  • Series summation is now more aggressively parallelized to improve CPU utilization on systems with many cores.
  • Slightly faster division and inverse square root.
  • Other:
  • Minor performance fluctuations across all processors due to internal refactorings and tuning parameter updates.
  • Minor UI changes due to internal refactorings.
  • Startup command line options are now documented in "Command Lines.txt".
  • Version 0.7.6 lands at the end of a very large refactor/rewrite of nearly all of y-cruncher series summation code.
  • Due to the scope of this refactor along with the fragility of the original code, there is non-zero probability that something will break in this version. Please submit a bug report if you observe errors or large increases in memory usage from older versions of y-cruncher.

New in y-cruncher 0.7.5 Build 9481 (Feb 25, 2018)

  • Fixed a bug that caused computations of e in ram only mode to compute e - 2 instead of e. This was due to some recent bad refactoring. It was not caught during testing since the spot checker only checks a subset of the digits.

New in y-cruncher 0.7.5 Build 9480 (Jan 22, 2018)

  • New Features:
  • Preliminary support has been added for Thread Building Blocks (TBB) for all 64-bit Windows binaries. This was prompted by the Cilk Plus deprecation. Support for Linux may come at a later time.
  • When a soft error is encountered in the stress-tester, it will display the logical core # that it occurred on. This will aid the user in tracking down "weak" cores during overclocking.
  • A new verification step has been added to complement the base conversion verification. This step reads back the decimal digits that were output to disk to make sure they are intact. This protects against several classes of errors that were previous unchecked:
  • Errors in formatting the digits. (i.e. converting from binary to ASCII)
  • Errors during the compression of the digits.
  • Errors in writing the digits to disk.
  • Like the base convert verification, this digit output verification is not part of the computation. Therefore, it is also excluded from the official benchmark times. This also maintains benchmark comparability with older versions of y-cruncher.
  • Both base convert and decimal digit verification are now classified as "Output Verification". They are disabled by default for casual benchmarks and enabled by default in the Custom Compute menu. Enabling them will be mandatory when claiming world record size computations.
  • Fixes:
  • Fixed a bug that may cause the base conversion to fail with, "Overlap Mismatch" error.
  • Optimizations:
  • Improved CPU utilization on systems with a lot of cores.
  • More optimizations that benefit memory-bound systems.
  • More AVX512 optimizations.
  • Other:
  • Minor performance fluctuations across all processors due to internal refactorings.

New in y-cruncher 0.7.4 Build 9478 (Dec 3, 2017)

  • Fixed a serious bug that could cause very large computations to fail a redundancy check.
  • This source of the bug is a refactoring that occurred between v0.7.3 and v0.7.4. Under very specific circumstances, it may cause a computational thread to overrun its designated scratch buffer and corrupt the memory of other threads.
  • The bug was missed by unit tests. And since it only reproduces on extremely large computations, it was also missed by the large scale integration tests. Thanks to Susumu Tsukamoto to catching this.

New in y-cruncher 0.7.4 Build 9477 (Oct 15, 2017)

  • New Features. Stress-Tester Revamp:
  • New tests: BBP and SFT. These two tests are designed to stay in cache and avoid the memory bottleneck that plagues the Skylake X processor line.
  • Full control has been added to choose which logical cores to test and which to leave idle.
  • On Linux, thread pinning is now more robust to unusual hardware configurations like disabled cores.
  • Tests now display how much memory is actually used.
  • Tests now show a slider indicating whether it is CPU-bound or memory-bound.
  • The stress-tester now has support for configuration files.
  • Fixes:
  • Fixed a bug that caused excessive memory usage with large task decompositions. It is now possible to do 25 billion digit Pi benchmarks within 128GB of memory with a lot of threads.
  • Fixed a subset of the BufferTooSmallException errors that occur in swap mode computations using a very small amount of memory. These are caused by incorrect pre-computation memory calculations. A more comprehensive fix is slated for the next feature release.
  • Retunings:
  • The "00-x86", "04-P4P", and "05-A64 ~ Kasumi" binaries have been re-tuned for AMD Phenom II.
  • "16-KNL" and "17-SKX" have been retuned for smaller caches.
  • Tuning parameters for most of the other binaries have been updated.
  • Optimizations:
  • Bulldozer: ~6%
  • Haswell: ~4%
  • Skylake: ~5%
  • Ryzen: ~6%
  • Skylake X: ~10%

New in y-cruncher 0.7.3 Build 9475 (Sep 15, 2017)

  • Fixed a bug that may cause ram only computations of e to fail with "Memory Allocation Failed".

New in y-cruncher 0.7.3 Build 9474 (Aug 16, 2017)

  • Fixed a bug that prevented the I/O benchmark from being run from a config file via command line.
  • Fixed a bug in the stress-tester that may cause improper thread binding.
  • Errors during stress-testing will be printed out immediately.
  • Speculative fix for bugged NUMA detection on AMD Threadripper and Eypc on Linux.

New in y-cruncher 0.7.3 Build 9472 (Jul 13, 2017)

  • Fixed a bug in Windows involving processor groups that prevents the stress-tester and the Push Pool framework from setting thread affinities on AMD Epyc systems with exactly 128 vcores. (Thanks to Dave Graham for reporting this.)

New in y-cruncher 0.7.3 Build 9471 (Jul 8, 2017)

  • New Features:
  • 17-SKX ~ Kotori: A new binary tuned for Skylake Purley processors with full-throughput AVX512.
  • 16-KNL: An untuned AVX512 binary that will run on Knights Landing Xeon Phi host processors.
  • Configuration Files:
  • The Custom Compute and I/O Benchmark menus now have support for saving to and loading from configuration files.
  • The functionalities for these menus can also be triggered directly from the command line with a configuration file.
  • Memory Allocator Improvements:
  • New memory allocators that support node interleaving. This may improve performance on NUMA systems.
  • Allocators now have sub-options that can be selected.
  • The memory allocator can now be set with the command line options.
  • On Windows, it is now possible to lock pages without using large pages.
  • Fixes:
  • Improved detection of available memory in Linux. In the past, it only detected unused pages. Now it detects all available memory including those used for caching which can be released if needed.
  • Invalid command-line options will now terminate the program instead of being silently skipped.
  • Fixed a bug in swap mode that causes the primary formula for the Euler-Mascheroni Constant to require much more memory than is necessary. This bug was introduced when fixing the "working memory is too small" bug in v0.7.2.
  • Fixed an issue in the Custom Compute swap mode menu that may cause it to fail an internal assertion. This is also related to the Euler-Mascheroni Constant memory calculations.
  • Other:
  • The dynamically-linked Linux binaries now have a dependency on libnuma due to the new node-interleaving allocators.
  • The concept of local and global "Min I/O Size" has been renamed and replaced with "Bytes per Seek".
  • The new features in this release may seem a bit loaded in terms of their magnitude given that it's only been a 4 months since the last major release. But in reality, most of the stuff has been a work-in-progress for a long time.

New in y-cruncher 0.7.3 Build 9468 (Jul 7, 2017)

  • New Features:
  • 17-SKX ~ Kotori: A new binary tuned for Skylake Purley processors with full-throughput AVX512.
  • 16-KNL: An untuned AVX512 binary that will run on Knights Landing Xeon Phi host processors.
  • Configuration Files:
  • The Custom Compute and I/O Benchmark menus now have support for saving to and loading from configuration files.
  • The functionalities for these menus can also be triggered directly from the command line with a configuration file.
  • Memory Allocator Improvements:
  • New memory allocators that support node interleaving. This may improve performance on NUMA systems.
  • Allocators now have sub-options that can be selected.
  • The memory allocator can now be set with the command line options.
  • On Windows, it is now possible to lock pages without using large pages.
  • Fixes:
  • Improved detection of available memory in Linux. In the past, it only detected unused pages. Now it detects all available memory including those used for caching which can be released if needed.
  • Invalid command-line options will now terminate the program instead of being silently skipped.
  • Fixed a bug in swap mode that causes the primary formula for the Euler-Mascheroni Constant to require much more memory than is necessary. This bug was introduced when fixing the "working memory is too small" bug in v0.7.2.
  • Fixed an issue in the Custom Compute swap mode menu that may cause it to fail an internal assertion. This is also related to the Euler-Mascheroni Constant memory calculations.
  • Other:
  • The dynamically-linked Linux binaries now have a dependency on libnuma due to the new node-interleaving allocators.
  • The concept of local and global "Min I/O Size" has been renamed and replaced with "Bytes per Seek".

New in y-cruncher 0.7.2 Build 9469 (Jun 5, 2017)

  • Fixed a serious bug in the Push Pool that could causes failures when limiting the # of threads. This bug was introduced in one of the many refactors between v0.7.1 and v0.7.2.

New in y-cruncher 0.7.2 Build 9468 (Apr 6, 2017)

  • The refactorings from v0.7.1 continue into this release. Other than that, there are few user-visible changes.
  • Due to the time-constraints with trying to make this happen for Pi Day, this release is not as well tested as it should've been. So don't be surprised if stuff breaks.
  • Fixes:
  • The Linux binaries will now properly read the CPU topology on multi-socket systems.
  • Fixed an integer overflow bug in I/O benchmark for the x86 binaries.
  • Fixed a corner case where computations of the Euler-Mascheroni Constant may fail with, "Working memory is too small."
  • New Features:
  • 17-ZD1 ~ Yukina: A new binary tuned for AMD Zen processors.
  • In Windows, y-cruncher will automatically create a minidump file if it crashes. This should make it easier to debug crashes which cannot be reproduced locally in the development environment.
  • The BBP app now has the option to pin all threads to different cores. This solves the problem of imbalanced processor groups.
  • Optimizations:
  • Minor speedups for most processors:
  • Penryn: ~6%
  • Nehalem: ~7%
  • Sandy Bridge: ~5%
  • Bulldozer: ~7%
  • Haswell: ~7%
  • Skylake: ~5%
  • Zen: ~14%
  • Retunings:
  • The default "Min IO" parameter has been raised to 1 MB to keep inline with modern hard drives.
  • Other:
  • The binaries have been renamed. Instead of using name of an instruction set, they now use a year and an acronym for the processor architecture instead. This was done because there are simply too many instruction sets and newer ones don't necessarily imply the existance of all the older ones.

New in y-cruncher 0.7.1 Build 9466 (Sep 23, 2016)

  • Fixes:
  • Fixed a bug in swap mode that causes objects to under-allocate. This sometimes leads to assertion failures about writing beyond the end of a swap file. This bug dates all the way back to the "risky" refactorings from v0.6.6. This took almost 2 years to catch because it only seems to affect the Euler-Mascheroni Constant.
  • For what it's worth, v0.7.1 has been surprisingly stable given the sheer magnitude of the internal changes.

New in y-cruncher 0.7.1 Build 9465 (Sep 23, 2016)

  • New Features:
  • Spot Checking: For computations of major constants, the digits are automatically spot-checked against a table of known digits. This was originally an internal feature meant to streamline QC testing. But it turned out to be useful enough to enable publicly. This feature completely replaces the ad hoc digit-checker used for Pi benchmarks.
  • x64 ADX ~ Kurumi: A new binary tuned for desktop Skylake processors. It utilizes the new add-with-carry instructions. This binary will also run on Broadwell processors.
  • The x86 binary (no SSE) is back. It disappeared for all of v0.6.x for performance reasons, but it's back for v0.7.1. The binary won't be able to run on any old processors anyway since Windows Vista or later is a requirement. But it's there for the purpose of comparing the effects of the various instruction sets.
  • Disk I/O buffer sizes are now configurable. In the past, they were locked to 64MB/path. This resulted in suboptimal performance when the path(s) were themselves a RAID of multiple drives.
  • When entering the number of digits, you can now specify suffixes. (e.g. "25m", "10b")
  • y-cruncher will now attempt to use large pages and lock them in memory to prevent destructive disk swapping by the OS.
  • HWBOT Integration Improvements:
  • Improved detection of the processor topology.
  • Added detection of the operating system version.
  • Added detection for the motherboard and memory configuration.
  • Added detection of the reference clock.
  • The validation files have been renamed so that they don't overwrite each other anymore.
  • Fixes:
  • Previously, y-cruncher would fail to pick up the username when running the binaries directly. This has been fixed.
  • Unicode is now properly handled everywhere in the program. Note that the ability to display unicode characters is still subject to the limitations of the console window.
  • Fixed a bug where checkpoint-restart would fail if any path had an equals character (=) in it.
  • The stress-tester and BBP app will now be able to use multiple processor groups.
  • Optimizations:
  • Global retunings for all processor-specific binaries. Expect both speedups and slowdowns across the board for all computations and on all processor targets. This is most noticable on older processors.
  • Swap mode computations are slightly more aggressive with keeping things in memory.
  • The initial memory allocation is now parallelized.
  • Other:
  • y-cruncher no longer requires administrator privileges to run basic computations. Instead, it will request that it be re-run with elevation for the following features:
  • Swap mode: Requires "SeManageVolumePrivilege".
  • Large pages: Requires "SeLockMemoryPrivilege".
  • In Windows, when you run y-cruncher by double-clicking, it will set the console window dimensions to 80 x 25. Windows has historically defaulted to a window size of 80 x 25. But in Windows 10, they increased this to 120 x 30 - which looks a bit weird.
  • The Custom Compute menu options have been rearranged a bit.
  • The licensing has been reworded to explicitly allow the use of y-cruncher for tech reviews even if they are for commercial purposes.

New in y-cruncher 0.6.9 Build 9464 (Sep 23, 2016)

  • Fixes:
  • Checkpoint restart will now properly save and restore the parallel framework. Previously, it would always load the default framework upon resuming a computation from a checkpoint. This bug has existed since v0.6.8 when parallel frameworks were added.
  • The framework threads will also be saved and restored across checkpoints.
  • Fixed a bug where the program may improperly detect the number of logical processors on Windows Server 2012 R2. This may also apply to other versions of Windows as well.
  • Fixed a bug in the x86 binaries that would prevent the I/O benchmark from using more than 4GB of disk.
  • Fixed a bug in the Digit Viewer where it fails to print new lines when counting digit frequencies.
  • Optimizations:
  • The threshold for defaulting to Cilk Plus has been increased from 33 to 65 logical cores.

New in y-cruncher 0.6.9 Build 9462 (Sep 23, 2016)

  • New Features:
  • On Windows, partial support has been added for Processor Groups:
  • The AVX, XOP, and AVX2 binaries are now able to detect all the logical cores in the system even if it exceeds 64.
  • The AVX and AVX2 binaries will default to Cilk Plus when there is more than one processor group.
  • The maximum task decomposition has been increased from 256 to 65,536.
  • This feature has not been added to the older SSE binaries because it requires Windows 7. As of v0.6.8, y-cruncher maintains backwards compatibility with Windows Vista. But all the AVX binaries require Windows 7 SP1 anyway, so nothing is lost by using Win7-specific API calls.
  • Fixes:
  • The app will no longer crash when AVX is disabled on a processor that supports it. This was a Visual Studio bug that was fixed by upgrading to Visual Studio 2015.
  • The command line option, "-C:-1" for compressing to a single file has been fixed. This was due to the (incorrect) use of an unsigned integer parser which parses -1 as zero thereby disabling compression.
  • The dispatcher will select AVX2 instead of SSE3 for AMD Zen.
  • Swap mode computations may cause excessive disk swapping by the OS. This has been alleviated by reducing the default memory usage from 31/32 of available memory to 15/16.
  • Optimizations:
  • The binaries that support Cilk Plus will default to Cilk Plus when there are more than 32 logical cores.
  • Minor speedups for specific architectures.
  • Compiler Upgrades:
  • Visual Studio 2013 -> 2015.

New in y-cruncher 0.6.8 Build 9461 (May 8, 2015)

  • Fixed a bug in the x86 binaries that was causing excessive memory usage.
  • Fixed a performance regression from v0.6.7 of up to 10% on older processors. This was the result of a bad refactor that accidentally replaced the size of the LLC (last level cache) with that of the L1 cache.
  • Fixed a bug in the BBP app where the compile-time CPU-dispatcher caused the "x64 SSE4.1 ~ Ushio" binary to use the "default" path instead of the SSE4.1 path.

New in y-cruncher 0.6.8 Build 9460 (Mar 24, 2015)

  • Fixed a performance regression from v0.6.7 that could slow down Haswell processors by as much as 5%.
  • Fixed a bug in the x86 binaries that would cause stack corruption when calculating the memory requirements for a computation larger than ~500 billion digits. This bug has been there since v0.6.1.

New in y-cruncher 0.6.7 Build 9457 (Feb 10, 2015)

  • Swap Mode Improvements:
  • Swap mode computations will now create a folder for the swap files. When multiple paths are used, each folder will have a unique name. This makes manual backups easier.
  • A swap mode multiplication tester has been added to the advanced options. Anyone who is attempting a world record with y-cruncher should first run this tester to sanity check the program's ability to do arithmetic at the target precision.
  • The I/O Benchmark has been revamped:
  • The old benchmark for strided access was vulnerable to request coalescing which cannot happen in a real computation. This was producing inflated bandwidth numbers. This has been somewhat mitigated in this version.
  • The recommendations have been updated to be more relevant for newer hardware.
  • For example, a stock i7 5960X would require around 6 GB/s of disk bandwidth. At 100 MB/s per hard drive, that would be 60+ drives assuming linear scaling. While it is easier to do it using SSDs, they are smaller in size. Furthermore, the sheer volume of writes that y-cruncher will issue means that if you want to use SSDs, you need to be willing to expend them like consumables.
  • Fixes:
  • Fixed a serious bug that would cause large multiplications to hit an assertion failure under the right conditions.
  • In Linux, swap files are now created with only the necessary permissions. (read+write for owner)
  • In the past, they were created with permissions 777 (everything). This was a huge oversight dating back to 2010 when the program was first ported to Linux.
  • Fixed a problem where swap mode in Linux wouldn't clean up the "pathcheck.ysf" file.
  • Fixed a minor console coloring problem.
  • Fixed a minor bug in swap mode that could cause suboptimal algorithm selection.
  • Fixed a bug in the multi-layer raid-file implementation that may cause the program to crash. This bug has existed since v0.6.1 and is extremely rare - requiring degenerate input data which may be impossible outside of a developer build.
  • Optimizations:
  • The XOP and AVX2 binaries are now faster.
  • The default "Min-IO Size" parameter has been reduced from 1MB to 256k.
  • Other:
  • On Windows, the stress tester now runs in the lowest possible priority to ensure responsiveness of CPU monitoring programs which also run in low priority.
  • On Windows, the default process priority has been reverted to "Below Average" for the same reason. As always, this priority can always be changed via Task Manager.
  • The minimum value for the "Min-IO Size" parameter has been reduced from 256k to 4k. SSDs as well as some hard drive configurations have very low average seek latencies which can benefit from a smaller Min-IO parameter.

New in y-cruncher 0.6.6 Build 9452 (Dec 22, 2014)

  • Fixed a problem where the "Min I/O" parameter would be incorrectly set when resuming from a computation using more than one drive. This bug has performance consequences for large swap mode computations.
  • Fixed an issue that could prevent the program from detecting errors when performing swap mode multiplications. Anything that could allow errors to go undetected is serious since it means that a computation could finish with the wrong digits.

New in y-cruncher 0.6.6 Build 9450 (Nov 20, 2014)

  • Fixed a bad regression in swap mode where disk I/O errors would not stop the computation. Instead, they would be ignored and the computation would continue with corrupted data.
  • Blame this on bad refactoring and insufficient corner-case testing...

New in y-cruncher 0.6.6 Build 9449 (Nov 11, 2014)

  • New Features:
  • Command Line Options
  • A "Stop on Error" option in the stress-tester to halt when an error is detected.
  • Critical Fixes:
  • Fixed an issue that can cause failures when using a non-power-of-two number of threads.
  • Fixed an issue that will cause most computations larger than 20 trillion digits to fail. This bug has existed since v0.6.1 and is caused by an off-by-one error in the creation of the precomputed twiddle factor tables.
  • Fixed an issue in the 32-bit versions that would cause Pi computations larger than 40 billion digits to fail the base convert verification. This was caused by an integer overflow in the "size_t" datatype when a 64-bit file offset should have been used instead. This bug has existed since v0.6.1 and was never caught because 32-bit y-cruncher has never been tested at such large sizes until now. (v0.6.1 does not support swap mode for Pi, so v0.6.2 is actually the earliest version that is affected.)
  • Minor Fixes:
  • Fixed some crashes that may occur when using a very large number of threads.
  • Fixed an issue when attempting to print a line that is longer 79 characters.
  • Fixed an issue in the I/O Benchmark that may cause parity failures under RAID 3.
  • Fixed another issue with detecting OS support for AVX.
  • Optimizations:
  • Swap mode computations now require ~10% less disk space than before.
  • Minor overall speedups.
  • Re-Tunings:
  • In Windows, the default process priority has been changed to "Normal". It used to be "Below Average".
  • Threads that perform disk I/O now run at the maximum priority that the OS will allow.
  • The program has been re-tuned in various ways. So expect some performance differences (both up and down) from the previous version.
  • The SSE3 binaries have been re-tuned in favor of larger computations. So they are faster for large computations, but slower for small ones. (similar to the SSE4.1 and AVX binaries in v0.6.3)
  • Internal Changes:
  • The compilers have been upgraded:
  • Intel Compiler (13 -> 14)
  • Visual Studio 2013 (Original -> Update 2)

New in y-cruncher 0.6.5 Build 9444 (Aug 26, 2014)

  • Fixed a bug in the base conversion that may cause a computation in swap mode to enter an infinite loop.
  • This bug has existed since v0.6.1 and only occurs when the number of threads is small (1 or 2). The cause of the bug is a subtle design flaw in the handling of misaligned data sizes. The fix was to align the data and delete the flawed misalignment code.

New in y-cruncher 0.6.5 Build 9442 (Jun 10, 2014)

  • New Features:
  • x64 AVX2 ~ Airi: A new binary tuned for Intel Haswell processors. It uses AVX2, FMA3, and BMI2 instructions.
  • The CPU dispatcher has been added to the Linux version.
  • Attempting to run a binary that is not compatible with the host will give a warning. An incompatible binary may still be able to run. But don't count on it.
  • Fixes:
  • Fixed the detection of AVX support by the OS. Previous versions only checked the OS version. It did not check if XSAVE was actually enabled to run AVX.
  • Units for memory have been changed to MiB/GiB/TiB etc... They have always been in binary, but the old labels were unclear as to whether it was binary or decimal.
  • The Linux version will attempt to reset the console colors to their defaults when the program exits.
  • Removed Features:
  • x64 SSE4.1 ~ Nagisa: This binary was tuned for my Harpertown workstation (Core 2 Penryn). But Core 2 is pretty old now and this binary has become redundant of the "x64 SSE4.1 ~ Ushio" binary. So not much is lost by dropping it. Getting rid of it also reduces the size of the download.
  • Internal Changes:
  • The entire CPU dispatching framework has been completely rewritten from scratch.
  • The underlying tool-chain has been completely revamped for this release. The AVX and AVX2 binaries use the Intel Compiler 13. The rest of them use Visual Studio 2013.
  • No optimizations have been done since the last release. But because of the compiler upgrades, there will be slight differences in performance since the previous version.

New in y-cruncher 0.6.4 Build 9424 (Apr 14, 2014)

  • New Features:
  • x64 XOP ~ Miyu:
  • A new binary tuned for AMD Bulldozer line processors. It uses FMA4 and XOP instructions.
  • Up to 10% faster than the SSE3 binary. (usually about 8% faster for large computations)
  • Fixes:
  • Fixed a bug in the inverse square root code that may cause the routine to under-estimate the amount of memory that is needed. The result is memory corruption when the computation uses more than is allocated.

New in y-cruncher 0.6.3 Build 9416b (Apr 14, 2014)

  • Bug fixes. One of which was bad enough to warrant patching v0.6.3 instead of waiting for v0.6.4.
  • Fixes:
  • Fixed a display issue where the secondary formula for Log(n) would show up as the "Primary Machin-Like Formula".
  • Fixed an issue in the Stress Tester where certain classes of soft-errors would not get reported.
  • Fixed a serious bug in the SSE3 binaries that would sometimes cause very large multiplications to fail.*
  • *This bug was introduced in v0.6.3 when the VST algorithm was refactored. I rewrote some of the processor-specific macros and screwed up the SSE3 version. The bug is rare and does not affect the SSE4.1 or AVX binaries.
  • This slipped through internal testing because it is rare and the SSE3 binaries are not tested as much as the SSE4.1 and AVX binaries.

New in y-cruncher 0.6.3 Build 9415 (Apr 14, 2014)

  • New Constants:
  • Lemniscate Constant
  • Euler-Mascheroni Constant: Not really new to y-cruncher, but it's back after disappearing for two versions.
  • New Features:
  • The Digit Viewer can now count the # of occurences of each digit.
  • The same digit counts are now logged in the validation files. This is useful for making sure that the process of writing the digits to disk is actually correct.
  • Errors are now more descriptive. This should aid in identifying whether issues are software or hardware related.
  • The validation files now contain a hash for the decimal digits. This can be used to verify that digits are correctly written to disk.
  • Fixes:
  • The Linux versions now correctly use O_DIRECT for raw I/Os.
  • AMD Bulldozer line processors will now choose "x64 SSE3 ~ Kasumi" instead of "x64 AVX ~ Hina". This is because 256-bit AVX performance on Bulldozer and Piledriver processors is worse than SSE3.
  • Tweaks:
  • The "x64 SSE4.1 ~ Ushio" and "x64 AVX ~ Hina" binaries have been re-tuned. They are slightly faster for large computations (> 1 billion digits). But performance for small computations has been decreased slightly.
  • The VST algorithm has been refactored in preparation for future instruction sets. So there will be some performance differences.
  • Changes:
  • The VST algorithm warning for AVX-capable processors has been removed. Prime95 appears to be more stressful now that it has support for AVX.
  • Checkpoints are now overlapping. Old checkpoints are not destroyed until the new checkpoint has been made. Previously, there were small portions of time when there would be no checkpoint alive. So if an error occured at just the right time, you'd be screwed.

New in y-cruncher 0.6.2 Build 9322 (Apr 14, 2014)

  • New Features:
  • Huvent's Formula for Catalan's Constant.
  • Swap Modes and Checkpoint restart have been added for all constants that v0.6.2 supports.
  • Resuming from a checkpoint will automatically remove all non-checkpoint files leftover from an interrupted computation.
  • Note that the checkpoint-restart in this version (0.6.2) has more granularity than in earlier versions. Checkpoints can now be made deep into the Binary Splitting recursions of all the series-based constants. Therefore the average time between checkpoints is much smaller and less work is lost upon a failure.
  • Changes:
  • All versions are now compiled using Visual Studio 2012. There may be slight changes in performance for all versions except the "x64 AVX ~ Hina" binary.
  • (Internal) - v0.6.2 now has a C++11 dependency. All prior versions of y-cruncher were compilable with only C99.
  • Regressions:
  • Swap modes require more disk space than in v0.5.x. This is because the checkpoint-restart requires that new checkpoints are written before (or shortly after) the previous checkpoint is destroyed. The result is that most operations must be done out-of-place thus increasing memory usage.
  • In v0.5.x, checkpoints were only done in places where disk usage was low. So the pressure of needing to preserve extra data was not felt. But in v0.6.2, checkpoints are everywhere - including places with high disk usage.
  • Fixes:
  • Fixed a bug where, in some scenarios, the program will halt with "Memory Allocation Failure".
  • Fixed some bugs that would cause small computations to error.
  • Fixed tons of other minor corner-case bugs.
  • Postponed features:
  • XOP and AVX2 support has been put off until I acquire the hardware.
  • Euler-Mascheroni Constant hasn't been started yet. (Although I should probably do this since that's what the "y" in "y-cruncher" stands for. Doesn't do much justice for a program to be missing its mascot. :P)
  • Lemniscate's Constant is "extremely low priority".
  • One thing worth noting is that the error-correction in v0.6.x is less aggressive than in v0.5.x. Version 0.6.2 relies more heavily on the new checkpoint-restart system to recover from errors. So instead of attempting to correct errors on the fly, v0.6.2 will usually just terminate the computation - thereby forcing the user to resume from the last checkpoint.

New in y-cruncher 0.6.2 Build 9282 (Apr 14, 2014)

  • New Features:
  • More Detailed Output: The program will display much more detailed output during a computation. This feature used to be developer and private-version only. But it is now enabled in all public releases.
  • Component Stress-Tester: Runs individual algorithms in y-cruncher to stress different parts of the system.
  • I/O Benchmark: Benchmarks and evaluates a swap configuration for large computations.
  • Multi-layer Raid-File:
  • Hybrid RAID 0+3 swap-file management to allow for redundancy while preserving the multi-HD functionality.
  • Compilation Options: An option that displays how each binary has been compiled. Originally a developer-only feature for development purposes, it has been enabled in the public release to satisfy those who are curious.
  • Removed Features:
  • Batch Benchmark Pi
  • The Stress-Tester from v0.5.5 and earlier.
  • Support for x86 without SSE3.
  • Basic Swap Mode
  • Changes:
  • Privilege elevation is now required to run y-cruncher. This should put an end to all those file allocation problems (which have gotten worse in Windows 8 due to the different UAC settings).
  • Windows Vista or higher is now required to run y-cruncher.
  • "Advanced Swap Mode" renamed to simply "Swap Mode".
  • The division step at the end of each series computation has been separated and given its own timer.
  • The "Frequency Sanity Check" has been disabled.
  • The validation files now include detailed event logs of the computation.
  • Limits:
  • All constants have a hard-limit of 90 trillion digits.
  • Optimizations:
  • Faster Division
  • Faster Square Roots
  • Faster Base Conversion
  • Faster Multiplication for large products > 50 billion digits
  • Numerous other minor optimizations
  • Fixes:
  • Detection for AVX on Windows 8 has been fixed.
  • Missing Features: The following features are not complete and will not be in this release. All of these exist in v0.5.5, so use that if you wish to use these features.
  • Checkpoint Restart
  • Swap Modes for: e, Pi, Log(n), Zeta(3), Catalan's Constant
  • Euler-Mascheroni Constant

New in y-cruncher 0.6x (Apr 14, 2014)

  • Due to the large feature set, these will be rolled out incrementally over multiple versions of v0.6.x.
  • New Features:
  • Component Stress-Tester: Runs individual algorithms in y-cruncher to stress different parts of the system.
  • I/O Benchmark: Benchmarks and evaluates a swap configuration for large computations.
  • Multi-layer Raid-File:
  • Hybrid RAID 0+3 swap-file management to allow for redundancy while preserving the multi-HD functionality.
  • Failed drives can be replaced on the fly without rolling back to a checkpoint.
  • Lemniscate Constant: Arc-length of a lemniscate = 5.24411510858423962...
  • Swap Mode added for the Euler-Mascheroni Constant.
  • Removed Features:
  • Batch Benchmark Pi
  • The current Stress-Tester
  • Support for x86 without SSE3.
  • Basic Swap Mode
  • Basic Swap Mode optimizations/algorithms*
  • Changes:
  • "Advanced Swap Mode" renamed to simply "Swap Mode".
  • Ramanujan's formula for Catalan's Constant will be replaced with Huvent's BBP. (and will support Swap Mode)
  • Completely overhauled Benchmark Validation system.
  • Limits:
  • All constants will have a hard-limit of 90 trillion digits.
  • Optimizations:
  • x64 XOP: Specially tuned for the AMD Bulldozer processor line.
  • Faster Base Conversion.
  • Faster Multiplication for large products > 50 billion digits.
  • More fine-grained Checkpoint-Restart.
  • Raw I/O support for Linux.
  • Numerous oher minor optimizations.
  • *Due to incompatibilities with new and future planned optimizations, Basic Swap Mode and the optimizations/algorithms that come with it (which are also used by Advanced Swap Mode) will be omitted in v0.6.x.
  • This, along with the rewrite, means that v0.6.x will be the first version of y-cruncher that will not be strictly faster than an e

New in y-cruncher 0.5.5 Build 9180 (Apr 14, 2014)

  • Fixes:
  • The x64 AVX ~ Hina binary is now compatible with non-Intel processors.
  • As a side-effect, the x64 AVX ~ Hina binary is about 1% faster on Intel processors as well.

New in y-cruncher 0.5.5 Build 9179 (Apr 14, 2014)

  • Fixes:
  • Fixed a major bug in the ArcCoth code that may cause incorrect computation of all dependent constants:
  • Log(2)
  • Log(10)
  • Euler-Mascheroni Constant
  • This bug has probably been present in y-cruncher since v0.4.1.

New in y-cruncher 0.5.5 Alpha Build 9178 (Apr 14, 2014)

  • New Features:
  • Support for the new Advanced Vector Extensions (AVX) instruction set.
  • Changes:
  • All Windows binaries with SSE/AVX are now compiled using the Intel Compiler 11.1.
  • All Linux binaries are now compiled using GCC 4.4.5. Furthermore, all binaries are compiled as C code, not C++.
  • Minor changes in speed due to rewritten code.
  • Optimizations:
  • x64 AVX ~ Hina:
  • Specially tuned for the Intel Sandy Bridge Core i7 processor line.
  • ~10% faster than x64 SSE4.1 on Sandy Bridge Core i7.
  • Requires Windows 7 Service Pack 1 or later.
  • The final output of digits at the end of each computation is now faster.
  • Note that this has no effect on benchmarks since outputting digits to disk does not count towards computation time.
  • The built-in Digit Viewer is now faster.
  • Fixes:
  • The Linux binaries are now statically linked.

New in y-cruncher 0.5.4 Build 9157 (Apr 14, 2014)

  • Optimizations (Linux):
  • Re-tuned I/O. This may or may not be faster than before. Note that raw I/Os are still not used because the current implementation is slower than using straight-forward buffered I/Os. (This is in contrary to Windows where raw I/Os are faster than buffered I/Os.)
  • Slightly improved speed. Added "-ffast-math" to the compile options.
  • New Features:
  • Colored console output has been added.
  • CPU brand detection has been added.
  • CPU frequency detection has been added.
  • Memory detection has been added.
  • Automatic memory selection has been enabled in Advanced Swap Mode.