All tests were performed on two hardware configurations. The same software configuration was on both hardware configurations.

The time complexity measure was used to evaluate the efficiency of the implemented ray tracing algorithm. The time required to execute a single-threaded CPU program is defined as: $$t_S = t_O + F_P W_L(S)$$ where $t_O$ is the time introduced by the non-deterministic overhead of the operating system due to the fact that at any point in time the operating system can perform tasks necessary for proper operation, $F_P$ is the floating-point operation time of the processor, and $W_L(S)$ is the total scene-dependent workload specified as follows: $$W_L(S) = \sum_{i=0}^{I_H} \sum_{j=0}^{I_W} g(S, x_j, y_i)$$ where:

• $I_H$ is the height of the rendered image,
• $I_W$ is the width of the rendered image,
• $g(S,x_i,y_j)$ is a function that defines the computational load depending on the scene $S$ and the specific pixel ($x_j, y_i$) of the image.

The relationship describing the time needed to execute a multi-threaded CPU program on $N$ threads is defined as: $$t_M = t_O + \frac{F_P W_L(S)}{N} + t_H$$ where $t_H$ is the total central processing unit time spent on threads handling. Due to the non-deterministic component $t_O$ present in the definitions of equations $t_S$ and $t_M$, averaged time measurements were introduced. Average execution time of a program running on single thread is specified as: $$T_S = \frac{\sum_{i=1}^{10}{t_{Si}}}{10}$$ and average execution time of a program running on multi-threads: $$T_M = \frac{\sum_{i=1}^{10}{t_{Mi}}}{10}$$ Finally, based on the equations $T_S and $T_M$ the formula for the acceleration could be defined as follows: $$S_M = \frac{T_S}{T_M}$$

In another test, image rendering using the same ray tracing algorithm using the graphics card was added to the comparison (represented as $T_G$ in the graph). It was also checked how the increase in the resolution of the rendered image affects the performance.

The conducted tests lead to the following conclusions:

• Skillful implementation of parallel computing leads to an increase in the efficiency of the algorithm.
• In the context of parallel computing, the CPU cannot compete with the GPU. The results of the much older NVIDIA GeForce 940MX (year of introduction 2016) outperformed the modern Intel i9 processor (year of introduction 2021).
• In the case of the central processing unit, increasing the number of compute units (threads) significantly improves the performance of the algorithms, the critical point is the number of physical threads in the CPU from that point on, there is no visible improvement.

Clone the project:

  git clone https://github.com/M-Komorek/Raytracer.git

Go to the project directory and compile code:

  cd Raytracer
  ./compile.sh

Rander image:

  ./build/Raytracer > image.ppm

To run tests, run the following command:

  ./compileAndTest.sh

C++17 - https://en.cppreference.com/w/cpp/17

OpenMp - https://www.openmp.org/

Google Test - https://github.com/google/googletest

CMake - https://cmake.org/