A common question people generally have is “What is High Performance Computing(HPC)?“. Intuition is – getting higher performance while solving some computational problem. You might want to look into to some books or some standard resources on the internet – you will definitely get the “formal” definition(s) of HPC. But, as a HPC engineer / budding researcher / parallel programmer, what I perceive HPC is as following (although not in any specific order, I have divided it into two parts)
Part I: the part which parallel programmers appreciate (and can be helpful with!)
* Convert your time consuming serial code into parallel code
This is the most common perception I see people have(at least in their early stages!)! They got the problem which takes hours (days? months?!) to get the solution. Thanks to multicore technology, today we have most of our computing systems – starting from desktops, workstations, servers (and mobile phones too!). You just need to parallelize your code to take advantage of the compute power available with your system. As far as the compute clusters/supercomputers are concerned, parallelization of your code will bring down computational time drastically!(Provided that you know Amdahl’s law! But, don’t forget Gustafson’s law!)
* Optimize your code
The initial code developed may not be the optimal one – it may have some redundant parts (yeah! that’s why people like me call it v0.1 rather than v1.0!), it may be the most naive implementation, it may not have computations/memory accesses which are most suitable for the given architecture and many other things. My point here is that – one may still go and tune/optimize the code to the best. If you know the platform on which this code is supposed to run – then you can go ahead and restructure your code/data structure to get maximum juice out of system.
(Not to mention the fellows who present speedups by comparing poor performing code with optimized and then parallelized code. The fair comparison is when you compare your optimized serial code with the parallel code.)
Part II: the part which domain experts appreciate (and can be helpful with!)
* Use better algorithm / numerical scheme
Using better algorithms which have less computational complexity will (theoretically) solve the given problem in lesser amount of time. One might use iterative methods / direct methods or use other techniques to converge faster towards solution with the given error tolerance or accuracy. (There is lot be written here – may be in some other post! Soon!)
* Use completely different mathematical model
With the changing computing trends (thanks to energy consumption of these computing systems!) new architectures/systems are evolving. The mathematical models developed/used for previous generation architectures may not be suitable for the new architectures. So, the new mathematical model/technique might give us solution in much shorter amount of time for the given problem. (Please search for video recordings of interesting talks on this!)
Given the objective – solve problem in shorter amount of time(with less computational resources?), I would refer HPC as combination of above interpretations!
Hopefully now you can add (or remove?) something to it and devise your own !