What is Exascale computing?
Exascale computing refers to computing systems capable of performing at least one exaflop, or 1018 floating-point operations per second, this is a thousand times greater than previous computer systems.
But what are flops?
Floating point operations involve floating point numbers – or numbers with a decimal point (0.1, 0.2, 0.3…).
Numbers with a decimal point represent fractional values and they are much more precise compared whole numbers/integers (1,2,3 ).
Operations using floating point numbers – such as addition, subtraction, multiplication and square roots – are more complex and take longer to perform compared with the same operations for integers.
As scientific calculations require the high precision of floating point numbers it is more useful to measure computer performance in FLOPS (Floating-Point Operations Per Second).
This value tells us how efficiently a computer can handle these more complex calculations.
Example of a floating-point operation
To put this into perspective, let’s measure how long it takes my computer to sum up an array of floating-point numbers using Python:
import numpy as np
import time
# Create an array of size 1000 of floating point numbers - ranging from 1 to 1000.
x = np.linspace(1, 1000, 1000)
# record the start time
start = time.time()
# perform the calculation/operation on the floating point numbers
calculation = sum(x)
# record the end time
end = time.time()
# measure and print out the elapsed time
elapsed_time = end - start
print(f"{elapsed_time}")Using the time module the result is 9.799003601074219e-05 seconds.
How fast is Exascale?
I mentioned Exascale is faster, but…..how much faster?
We can take our earlier example (the array sum operation) and make a theoretical estimate for how long it would take on an Exascale computer.
The number of addition operations needed for an array of size N is N-1 and we know the number of Floating-Point Operations Per Second (FLOPS) for an Exascale machine is at least 1018, therefore:
N = len(x) # N = 1000
flops = N - 1 # flops = 999
exascale_flops_per_second = 10**18
exascale_time = flops / exascale_flops_per_secondThis gives us a value of 9.99e-16 seconds, which we can see is insanely fast.
For reference the blink of a human eye is around 100 milliseconds and our exascale operation takes
0.0979 milliseconds, quite literally faster than a blink of an eye.
By dividing the Exascale time by the time it took my humble laptop to perform the same operation we can calculate the speedup as:
speedup = 9.79e-05 / 9.99e-16 = 9.79e+10
This is around 98 billion times faster!
In reality, a simple operation like summing an array would not fully utilise an exascale system, but this estimate gives us an idea of the powerful capabilities of exascale setups.
So what about more complex operations and how can we take full advantage of this amazing new resource?
In the next few posts I will share some interesting things I learned at the Algorithms for Exascale computing workshop hosted by Exeter University, stay tuned!