The Golden Ratio
is one of the oldest and most visible irrational numbers known to humanity. Pi
is perhaps more famous, but the Golden Ratio
is found in more of our art, architecture, and culture throughout human history.
I think of the Golden Ratio as sort of "Pi in 1 dimension". Whereas Pi is the ratio of a circle's circumference to its diameter, the Golden Ratio is the ratio of a whole to one of its parts, when the ratio of that part to the remainder is equal.
Visually, this diagram from Wikipedia
helps explain it:
We find the Golden Ratio in the architecture of antiquity, from the Egyptians to the Greeks to the Romans, right up to the Renaissance and even modern times.
While the base of the pyramids are squares, the Golden Ratio can be observed as the base and the hypotenuse of a basic triangular cross section like so:
The floor plan of the Parthenon has a width/depth ratio matching the Golden Ratio...
For the first 300 years of printing, nearly all books were printed on pages whose length to width ratio matched that of the Golden Ratio.
From school, you probably remember that the Golden Ratio is approximately ~1.6 (and change).
There's a strong chance that your computer or laptop monitor has a 16:10 aspect ratio. Does 1280x800 or 1680x1050 sound familiar?
That ~1.6 number is only an approximation, of course. The Golden Ratio is in fact an irrational number and can be calculated to much greater precision through several different representations, including:
You can plug that number into your computer's calculator and crank out a dozen or so significant digits.
However, if you want to go much farther than that, Alexander Yee
has created a program called y-cruncher
, which as been used to calculate most of the famous constants to world record
precision. (Sorry free software readers of this blog -- y-cruncher is not open source code...)
I came across y-cruncher
a few weeks ago when I was working on the mprime
post, demonstrating how you can easily put any workload into a Docker
container and then produce both Juju
Charms and Ubuntu Snaps
that package easily. While I opted to use mprime
in that post, I saved y-cruncher
for this one :-)
Also, while doing some network benchmark testing of The Fan Networking
among Docker containers, I experimented for the first time with some of Amazon's biggest instances, which have dedicated 10gbps network links. While I had a couple of those instances up, I did some small scale benchmarking of y-cruncher
Presently, none of the mathematical constant records are even remotely approachable with CPU and Memory alone. All of them require multiple terabytes of disk, which act as a sort of swap space for temporary files, as bits are moved in and out of memory while the CPU crunches. As such, approaching these are records are overwhelmingly I/O bound -- not CPU or Memory bound, as you might imagine.
After a variety of tests, I settled on the AWS d2.2xlarge instance size
as the most affordable
instance size to break the previous Golden Ratio
record (1 trillion digits, by Alexander Yee on his gaming PC in 2010). I say "affordable", in that I could have cracked that record "2x faster" with a d2.4xlarge or d2.8xlarge, however, I would have paid much more (4x) for the total instance hours. This was purely an economic decision :-)
Let's geek out on technical specifications for a second... So what's in a d2.2xlarge?
- 8x Intel Xeon CPUs (E5-2676 v3 @ 2.4GHz)
- 60GB of Memory
- 6x 2TB HDDs
First, I arranged all 6 of those 2TB disks into a RAID0 with mdadm
, and formatted it with xfs
(which performed better than ext4 or btrfs in my cursory tests).
$ sudo mdadm --create --verbose /dev/md0 --level=stripe --raid-devices=6 /dev/xvd?
$ sudo mkfs.xfs /dev/md0
$ df -h /mnt
/dev/md0 11T 34M 11T 1% /mnt
Here's a brief look at raw read performance with hdparm:
$ sudo hdparm -tT /dev/md0
Timing cached reads: 21126 MB in 2.00 seconds = 10576.60 MB/sec
Timing buffered disk reads: 1784 MB in 3.00 seconds = 593.88 MB/sec
The beauty here of RAID0
is that each of the 6 disks can be used to read and/or write simultaneously, perfectly in parallel. 600 MB/sec is pretty quick reads by any measure! In fact, when I tested the d2.8xlarge, I put all 24x 2TB disks into the same RAID0 and saw nearly 2.4 GB/sec read performance across that 48TB array!
With /dev/md0 mounted on /mnt and writable by my ubuntu user, I kicked off y-crunch with these parameters:
Program Version: 0.6.8 Build 9461 (Linux - x64 AVX2 ~ Airi)
Constant: Golden Ratio
Algorithm: Newton's Method
Decimal Digits: 2,000,000,000,000
Hexadecimal Digits: 1,660,964,047,444
Threading Mode: Thread Spawn (1 Thread/Task) ? / 8
Computation Mode: Swap Mode
Working Memory: 61,342,174,048 bytes ( 57.1 GiB )
Logical Disk Usage: 8,851,913,469,608 bytes ( 8.05 TiB )
was very handy here, being able to track in the bottom status bar my CPU load, memory usage, disk usage, and disk I/O, as well as connecting and disconnecting from the running session multiple times over the 4 days of running.
And approximately 79 hours later, it finished successfully!
Start Date: Thu Jul 16 03:54:11 2015
End Date: Sun Jul 19 11:14:52 2015
Computation Time: 221548.583 seconds
Total Time: 285640.965 seconds
CPU Utilization: 315.469 %
Multi-core Efficiency: 39.434 %
5027026274 0209627284 1999836114 2950866539 8538613661 : 1,999,999,999,950
2578388470 9290671113 7339871816 2353911433 7831736127 : 2,000,000,000,000
Amazing, another person (who I don't know), named Ron Watkins, performed the exact same computation and published his results within 24 hours, on July 22nd/23rd. As such, Ron and I are "sharing" credit for the Golden Ratio record.
Now, let's talk about the economics here, which I think are the most interesting part of this post.
Look at the above chart of records, which are published on the y-cruncher
page, the vast majority of those have been calculated on physical PCs -- most of them seem to be gaming PCs
What's different about my approach is that I used Linux in the Cloud -- specifically Ubuntu
. I paid hourly (actually, my employer, Canonical
, reimbursed me for that expense, thanks!) It took right at 160 hours to run the initial calculation (79 hours) as well as the verification calculation (81 hours), at the current rate of $1.38/hour for a d2.2xlarge, which is a grand total of $220!
$220 is a small fraction of the cost of 6x 2TB disks, 60 GB of memory, or 8 Xeon cores, not to mention the electricity and cooling required to run a system of this size (~750W) for 160 hours.
If we say the first first trillion digits were already known from the previous record, that comes out to approximately 4.5 billion record-digits per dollar, and 12.5 billion record-digits per hour!
Hopefully you find this as fascinating as I!