Improved Documentation

Author: khushi-411

benchmarks/python/compiled_methods.py

@@ -25,7 +25,9 @@ def compute_accelerations(accelerations, masses, positions):
     for index_p0 in range(nb_particles - 1):
         position0 = positions[index_p0]
         mass0 = masses[index_p0]
-
+        
+        # TODO: Use compiled methods like Numba & Pythran in vectorized approach.
+        # Issue: https://github.com/khushi-411/numpy-benchmarks/issues/4
         for index_p1 in range(index_p0 + 1, nb_particles):
             mass1 = masses[index_p1]
 

benchmarks/python/plot.py

@@ -24,7 +24,7 @@ def plot(x, labels, list_df, names):
     plt.yticks(fontsize=300)
     plt.legend(fontsize=250)
 
-    plt.ylabel(r'$\frac{Time}{nParticles^2}$', fontsize=350)
+    plt.ylabel(r'$\frac{Time}{nParticles}{(sec)}$', fontsize=350)
     plt.xlabel(r"$Number\ of\ Particles\ Simulated(nParticles)$", fontsize=270)
     plt.title(r"$Library\ based\ Implementation$", fontsize=300)
 
@@ -47,7 +47,7 @@ def plot(x, labels, list_df, names):
     plt.yticks(fontsize=300)
     plt.legend(fontsize=250)
 
-    plt.ylabel(r'$\frac{Time}{nParticles^2}$', fontsize=350)
+    plt.ylabel(r'$\frac{Time}{nParticles}{(sec)}$', fontsize=350)
     plt.tick_params(axis='x', which='major', pad=50)
     plt.xlabel(r"$Number\ of\ Particles\ Simulated(nParticles)$", fontsize=270)
     plt.title(r"$Compiler\ based\ Implementation$", fontsize=300)
@@ -57,7 +57,7 @@ def plot(x, labels, list_df, names):
 
 if __name__ == "__main__":
 
-    data_path = "data/table.csv"
+    data_path = "benchmarks/data/table.csv"
     df = pd.read_csv(data_path)
     df = df.drop(['Unnamed: 0'], axis=1)
     df = df.T

content/en/benchmark.md

@@ -3,12 +3,11 @@ title: NumPy Benchmarks
 sidebar: false
 ---
 
-<img src = "/images/content_images/performance_benchmarking.png" alt = "Visualization" title = "Performance Benchmark; Number of Iterations: 5">
-
+<img src = "/images/content_images/performance_benchmarking.png" alt = "Visualization" title = "Performance Benchmark; Number of Iterations: 50">
 
 ## Overview
 
-This blog post aims to benchmark NumPy's performance on the widely accepted N-body problem<a href="#nbody">[2]</a>. This work also compares NumPy with other popular libraries like pure Python and C++ and compilers like Numba and Pythran.
+This web page aims to benchmark NumPy's performance on the widely accepted N-body problem<a href="#nbody">[2]</a>. This work also compares NumPy with Python & C++ and with compilers like Numba and Pythran.
 
 The objective of benchmarking NumPy revolves around the efficiency of the library in quasi real-life situations, and the N-body problem suits the purpose well. Benchmarking is performed over several iterations for different datasets to ensure the accuracy of the results.
 
@@ -21,10 +20,10 @@ The objective of benchmarking NumPy revolves around the efficiency of the librar
 <!-- 2. About N-body Problem: Brief description on N-body problem and why it was chosen. -->
 <!-- 3. Dataset Description -->
 <!-- 4. Implemented Accelerators -->
-<!-- 5. Results -->
-<!-- 6. Source Code -->
-<!-- 7. References -->
-
+<!-- 5. Source Code -->
+<!-- 6. Results -->
+<!-- 7. Conclusion -->
+<!-- 8. References -->
 
 ## About N-Body Problem
 
@@ -46,23 +45,27 @@ From the definition above, the N-body problem includes the kinematics between th
 
 A brief description of computations involved in solving the N-body problem is given below, along with the pseudo-code in the next section:
 
-Consider $n$ bodies of masses $m_1, m_2, m_3, ... , m_n$, moving under the mutual [gravitational force](https://en.wikipedia.org/wiki/Gravity) of attraction between them in an [inertial frame of reference](https://en.wikipedia.org/wiki/Inertial_frame_of_reference) of three dimensions, such that consecutive  positions and velocities of an ${ith}$ body are denoted by ($s_{i-1}$, $s_i$) and ($v_{i-1}$, $v_i$) respectively. The gravitational force felt on the $ith$ body of mass $m_i$ by a single body of mass $m_j$ is denoted as $F_{gravitational}$ and the acceleration of the $ith$ body is represented as $a_i$. Consider the position vectors of these two bodies as $r_i$ and $r_j$.
+Consider $n$ bodies of masses $m_1, m_2, m_3, ... , m_n$, moving under the mutual [gravitational force](https://en.wikipedia.org/wiki/Gravity) of attraction between them in an [inertial frame of reference](https://en.wikipedia.org/wiki/Inertial_frame_of_reference) of three dimensions, such that consecutive  positions and velocities of an ${ith}$ body are denoted by ($s_{k-1}$, $s_k$) and ($v_{k-1}$, $v_k$) respectively. According to the [Newton's law of gravity](https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation), the gravitational force felt on the $ith$ body of mass $m_i$ by a single body of mass $m_j$ is denoted as $F_{ij}$ and the acceleration of the $ith$ body is represented as $a_i$. Let $r_i$ and $r_j$ be the position vectors of two body, such that:
+
+\begin{equation} {r_i} = {s_{k+1}} - {s_{k}} \tag{I} \end{equation}
+
+\begin{equation} {r_j} = {r_{k}} - {r_{k+1}} \tag{II} \end{equation} 
 
 The final aim is to find time taken to evaluate the total energy of each particle in the celestial space at a given time step. The equations involved in solving the problem are listed below:
 
-\begin{equation} {s_i} = {s_{i-1}} + {u\times t} + \frac{a\times t^2}{2} \tag{i} \end{equation}
+\begin{equation} {s_k} = {s_{k-1}} + {u\times t} + \frac{a\times t^2}{2} \tag{III} \end{equation}
 
-\begin{equation}{v_i} = {v_{i-1}} + {a\times t} \tag{ii} \end{equation}
+\begin{equation}{v_k} = {v_{k-1}} + {a\times t} \tag{IV} \end{equation}
 
-\begin{equation} {F_{ij}} = \frac{{G\times {m_i}\times {m_j}}\times \mid {r_j}-{r_i} \mid}{{\mid {r_j}-{r_i} \mid}^3} \tag{iii} \end{equation}
+\begin{equation} {F_{ij}} = \frac{{G\times {m_i}\times {m_j}}\times \mid {r_j}-{r_i} \mid}{{\mid {r_j}-{r_i} \mid}^3} \tag{V} \end{equation}
 
-\begin{equation} {a_{i}} = \frac{F_{ij}}{m_{j}} \tag{iv} \end{equation}
+\begin{equation} {a_{i}} = \frac{F_{ij}}{m_{j}} \tag{VI} \end{equation}
 
-\begin{equation} \textrm{Self Potential Energy} = \textrm{U} = -\frac{{m_i}\times {m_j}}{r^2} \tag{v} \end{equation}
+\begin{equation} \textrm{Self Potential Energy} = \textrm{U} = -\frac{{m_i}\times {m_j}}{r^2} \tag{VII} \end{equation}
 
-\begin{equation} \textrm{Kinetic Energy} = \textrm{K.E} = \frac{\sum m\times v^2}{2} \tag{vi} \end{equation}
+\begin{equation} \textrm{Kinetic Energy} = \textrm{K.E} = \frac{\sum m\times v^2}{2} \tag{VIII} \end{equation}
 
-\begin{equation} \textrm{Total Energy} = \textrm{Kinetic Energy} + \textrm{Self Potential Energy} \tag{vii} \end{equation}
+\begin{equation} \textrm{Total Energy} = \textrm{Kinetic Energy} + \textrm{Self Potential Energy} \tag{IX} \end{equation}
 
 ### Pseudo Code of Solving N-body Problem
 
@@ -74,11 +77,11 @@ FOR time is less than or equal to time_end
     Calculate total initial energies:
         Calculate kinetic energy
         Calculate potential energy
-    FOR i less than number_of_step
-        Calculate positions (r[i+1])
+    FOR k less than number_of_step
+        Calculate positions (r[k+1])
         Swap accelerations
         Calculate accelerations
-        Calculate velocities (v[i+1])
+        Calculate velocities (v[k+1])
         Increment time
         IF number_of_step % 100 is not 0 THEN
             Calculate total energy
@@ -110,17 +113,10 @@ We considered accelerators like [Numba](http://numba.pydata.org/), [Pythran](htt
 
 <div style="text-align: right">Source: <a href="http://numba.pydata.org/">Numba's Website</a></div>
 
-Since Numba is a compiler focused on accelerating Python and NumPy codes, the user API of the library supports various decorators. The supported decorators are `@jit, @vectorize, @guvectorize, @stencil, @jitclass, @cfunc, @overload`. It also supports `nopython` mode to generate fully compiled results without the need for intermediate Python interpreter calls. Numba's assistance to NumPy arrays and functions also makes it a good candidate for comparison.
+Since Numba is a compiler focused on accelerating Python and NumPy codes, the user API of the library supports various decorators. It uses the industry-standard LLVM compiler library. It aims to translate the Python functions to optimized machine code during runtime. It supports variety of decorators like `@jit, @vectorize, @guvectorize, @stencil, @jitclass, @cfunc, @overload`. We are using `Just-In-Time` compilation in this work. It also supports `nopython` mode to generate fully compiled results without the need for intermediate Python interpreter calls. Numba's assistance to NumPy arrays and functions also makes it a good candidate for comparison.
 
 <!-- NumPy and Numba both use a similar type of compilation for ufuncs in manual looping resulting in the same speed.  Another thing that Numba lacks behind is that it does not support all functions of NumPy. There are functions in NumPy which does not hold up some of the optional arguments in nopython mode. It can implement linear algebra calls in the compiled functions but does not return any faster implementation. -->
 
-Implementation details for benchmarking:
-
-* `jit` decorator from Numba was used to compile the Python functions just-in-time.
-* `cache = True`: To avoid repetitive compile time.
-* Uses NumPy arrays and loops.
-* Implemented `jit` decorated functions to call another `jit` decorated functions to increase the performance of our model.
-
 ### Pythran
 
 > Pythran is an ahead of time compiler for a subset of the Python language, with a focus on scientific computing.
@@ -131,9 +127,51 @@ Since the focus of Pythran was on accelerating Python and NumPy codes, its C++ A
 
 <!-- NumPy arrays in Cython should be stored in contiguous memory like C-style or Fortran to use Pythran in the backend. Here, the Pythran lacks behind. Another limitation is that the sequence of bytes of words must be the same as the targeted architecture to make Pythran work.-->
 
+## Source Code
+
+* The code is inspired by <a href = "https://github.com/paugier/nbabel">Pierre Augier's work on N-Body Problem</a>.
+* Visualization Code: <a href = "/benchmarks/python/plot.py">here</a>.
+
+<html>
+<head>
+<style>
+table, th, td {
+  border: 1px solid black;
+  border-collapse: collapse;
+}
+</style>
+</head>
+ <table>
+  <tr>
+   <td><b>Algorithm & Source Code</b></td>
+   <td><b>Implementation Details</b></td>
+  </tr>
+  <tr>
+   <td><a href = "/benchmarks/python/optimized_numpy.py">NumPy</a></td>
+   <td>Vectorized Approach, Broadcasting Method, NumPy Arrays</td>
+  </tr>
+  <tr>
+   <td><a href = "/benchmarks/python/pure_python.py">Python</a></td>
+   <td>Standard Python Approach, Using List</td>
+  </tr>
+ <tr>
+  <td><a href = "/benchmarks/cpp/main.cpp">C++</a></td>
+  <td>C++ Implementation, GNU C++ Compiler</td>
+ </tr>
+ <tr>
+   <td><a href = "/benchmarks/python/compiled_methods.py">Numba</a></td>
+   <td>Just-In-time Compilation, Non-Vectorized Approach, Using Numba at the Backend via Transonic, NumPy Arrays</td>
+  </tr>
+ <tr>
+  <td><a href = "/benchmarks/python/compiled_methods.py">Pythran</a></td>
+  <td>Just-In-Time Compilation, Non-Vectorized Approach, Pythran at the Backend via Transonic, NumPy Arrays</td>
+ </tr>
+ </table>
+</html>
+
 ## Results
 
-Table values represent the normalized time taken in seconds by each algorithm to run on the given datasets for $5$ number of iterations.
+Table values represent the normalized time taken in seconds by each algorithm to run on the given datasets for $50$ number of iterations. The raw timing data can be downloaded from <a href = "benchmarks/data/table.csv">here</a>.
 
 <html>
 <head>
@@ -152,99 +190,80 @@ table, th, td {
   <td><b>32</b></td>
   <td><b>64</b></td>
   <td><b>128</b></td>
+  <td><b>256</b></td>
  </tr>
  <tr>
   <tr>
   <td><b>NumPy</b></td>
   <td>12.61</td>
   <td>13.88</td>
   <td>15.59</td>
-  <td>17.9</td>
+  <td>17.90</td>
+  <td>18.27</td>
  </tr>
 <tr>
   <td><b>Python</b></td>
   <td>12.85</td>
   <td>26.82</td>
   <td>50.13</td>
   <td>105.01</td>
+  <td></td>
 </tr>
  <tr>
   <td><b>C++</b></td>
   <td>1.646</td>
   <td>3.206</td>
   <td>5.725</td>
   <td>11.44</td>
+  <td>19.43</td>
  <tr>
   <td><b>Numba</b></td>
   <td>1.567</td>
   <td>3.223</td>
   <td>6.521</td>    
   <td>13.64</td>
+  <td>26.64</td>
  </tr>
  <tr>
   <td><b>Pythran</b></td>
   <td>0.3177</td>
   <td>0.6591</td>
   <td>1.2811</td>
   <td>2.5082</td>
+  <td>5.2042</td>
  </tr>
 </table>
 </body>
 </html>
 
-**Note** on machine configuration used for benchmarking:
+## Environment configuration
 
-* **Machine:** Intel(R) Core(TM) i7-10870H CPU @ 2.20GHz, 16GB RAM
+* **CPU Model:** Intel(R) Core(TM) i7-10870H CPU @ 2.20GHz
+* **RAM GB:** 16
+* **RAM Model:** DDR4
+* **Speed:** 3200 MT/s
 * **Operating System:** Manjaro Linux 21.1.1, Pahvo
 * **Library Versions:**
     * Python: 3.9.6
     * NumPy: 1.20.3
     * Numba: 0.54.0
     * Pythran: 0.9.12.post1
     * Transonic: 0.4.10
+    * GCC: 11.1.0
 
-## Source Code
+## Conclusion
 
-* The code is highly inspired by <a href = "https://github.com/paugier/nbabel">Pierre Augier's work on N-Body Problem</a>.
-* Visualization Code: <a href = "/benchmarks/python/plot.py">here</a>.
+* NumPy is very efficient, especially for larger datasets. NumPy performs $3.2$ times faster than Python for input size $64$, $5.8$ times faster for a dataset of size, $128$, and $$ times better performance than Python for input size $256$. The performance of NumPy increases drastically as the number of particles in the datasets increases. Thanks to the vectorized approach in NumPy. Vectorization makes the code look clean and concise to read. It results in better performance without any explicit looping, indexing, etc. NumPy's concept of vectorization is handy for the beginner to learn. It is also beneficial for a highly skilled developer to debug the errors with fewer lines of code.
+* It uses pre-compiled C code, which adds up to the performance of NumPy. We can observe from the table the performance of the NumPy approaches to the speed of C++. For a dataset of size $64$, NumPy is $2.72$ times slower than C++. For the dataset of size $128$, it reaches equivalent to the speed of C++, with a running time of $1.56$ times the time taken by C++. NumPy outperforms C++ by $1.06$ times for input size $256$.
 
-<html>
-<head>
-<style>
-table, th, td {
-  border: 1px solid black;
-  border-collapse: collapse;
-}
-</style>
-</head>
- <table>
-  <tr>
-   <td><b>Algorithm & Source Code</b></td>
-   <td><b>Implementation Details</b></td>
-  </tr>
-  <tr>
-   <td><a href = "/benchmarks/python/optimized_numpy.py">NumPy</a></td>
-   <td>Vectorized Approach</td>
-  </tr>
-  <tr>
-   <td><a href = "/benchmarks/python/pure_python.py">Python</a></td>
-   <td>Standard Python Approach</td>
-  </tr>
- <tr>
-  <td><a href = "/benchmarks/cpp/main.cpp">C++</a></td>
-  <td>C++ Implementation, GNU C++ Compiler</td>
- </tr>
- <tr>
-   <td><a href = "/benchmarks/python/compiled_methods.py">Numba</a></td>
-   <td>Just-In-time Compilation, Non-Vectorized Approach, Numba via Transonic Compiler</td>
-  </tr>
- <tr>
-  <td><a href = "/benchmarks/python/compiled_methods.py">Pythran</a></td>
-  <td>Just-In-Time Compilation, Non-Vectorized Approach, Pythran via Transonic Compiler</td>
- </tr>
- </table>
-</html>
+**How can we accelerate NumPy?**
+
+NumPy aims to improve itself and to give better performance for the end-users. It performs well in most cases. But to fill the gaps where NumPy is not so good various compiled methods like Numba, Pythran, etc are used. They play a huge role. In this implementation, we used Transonic's JIT Compilation at the backend for NumPy arrays to implement Numba & Pythran. To be specific, we want to compare NumPy's vectorized approach with the JIT-compiled non-vectorized approach.
+
+* We observed Numba performs $2.72$ times faster than NumPy for input size $64$ and $1.56$ times faster for input size $128$. But later, NumPy outperforms Numba by $1.45$ times faster for input size $256$.
+* Pythran performs $12.17$ times faster for input size $64$, $7.13$ times better for input size $128$, and $3.51$ times faster than NumPy for input size $256$.
 
+We have compared the performance of NumPy with two of the most popular languages Python and C++, and with popular compiled methods like Numba and Pythran. NumPy achieves better performance for scientific computations as well as for solving real-life situations. That's NumPy. It stands explicitly well in all kinds of circumstances.
 
 ## References