Sage Journals: Discover world-class research

Abstract

The prime goal of parallel computing is the simultaneous parallel execution of several program instructions. Consequently, to accomplish this, the program should be divided into independent sets so that each processor can execute its program part concurrently with the other processors. This study compares OMP and MATLAB, two important parallel computing simulation tools, through the use of a dense matrix multiplication technique. The results showed that OMP outperformed the MATLAB parallel environment by over 8 times in sequential execution and 6 times in parallel execution. From this proposed method, it was also observed that OMP with an even slower processor performs much better than MATLAB with a higher processor. Thus, the present analysis indicates that OMP is a superior environment for parallel computing and should be preferred over parallel MATLAB.

Keywords

Parallel computing OMP MATLAB matrix multiplication

1. Introduction

Parallel computation can be achieved on an individual computer with multiple processors, or many individual computers connected by a network or a combination of the two. Application of Open MP (OMP) and MATLAB parallel environments are focused in this study with the help of illustrations to evaluate the performance of both tools. OMP stands for Open Multi-Processing. For shared memory thread-based parallel programming applications, this programming interface offers a scalable and portable approach. On a supported platform, OMP’s adaptability and user-friendly design make it incredibly simple by enhancing the source code with recently introduced directives [1, 2, 3, 4].

The master thread, or single process, is the starting point of every OMP program. Until the first parallel region construct is met, this master thread executes in sequential order. OMP executes in parallel using the fork-join mechanism. Since parallelization is explicitly controlled by the programmer in this instance, parallelism is approached with clarity. MATLAB software package performs analytical studies to solve different engineering problems. Parallel computing in MATLAB splits up the problem across multi-core or multiple computer nodes in a variety of ways. It can also support multithreading natively, which can be broadly compared to the OMP approach to parallelism. Parfor and spmd commands are used to achieve parallelism in MATLAB [5]. There were 13 problems significant for applications of science and engineering as per academic research at Berkeley University, USA [6]. These 13 problems include the ‘Dense Linear Algebra’ which consists of the Matrix Multiplication (MM) method. The selection of the MM problem is due to its wide applicability in the flexibility of matrix indexing and numerical programming [9]. It is one of the significant parallel algorithms concerning data locality, cache coherency, etc. [7, 8]. The problem of computing the product $C=A\times B$ of two large, dense, matrices was considered.

2. Related work

Due to the introduction of supercomputers with massively parallel architectures in the 1980s, parallel computation has grown in popularity. Many parallel computing systems exist, including parallel MATLAB, Open MP, CUDA (Compute Unified Device Architecture), MPI (Message Passing Interface), PVM (Parallel Virtual Machine), and so on [10]. In the last ten years, several studies have been conducted to evaluate the effectiveness of various algorithms in parallel settings. Dash et al. [11] presented an overview of optimization methods that may be used for the MM algorithm, and [12] assessed the performance in the OMP parallel environment. It was investigated how well the MM algorithms performed in an MPI context [13]. Previous research also examined the MM problem to identify the effects of parallelism on issue size. However, that study was limited to a quite smaller sample size [14]. Using the OMP platform, several experiments [15, 16, 17] have been conducted to assess the MM algorithm’s performance on multi-core processors. Efficiency was not assessed in related experiments published by authors [14, 15, 16, 17]. Efficiency has been computed in the current study, and consideration was given to the size of the performance matrix (5000 $\times$ 5000) for evaluation.

In computer science, parallelism is the practice of carrying out several activities concurrently within a single program. It might be added during compilation or execution, or it can be specified in the source code of a program. By dividing programs into jobs that may run in parallel, completing separate responsibilities, or handling various portions of the work, parallelism can improve efficiency or responsiveness [18]. A recent study suggested a concurrent data structure that is scalable for shared memory systems, balancing components and optimizing priority queues to ensure effective operation execution [19]. Programming languages give the necessary information for static analysis and compiler execution, enabling effective calculation and safety verification of programs. A high-level perspective is offered by high-level programming abstractions, which enable programmers to directly describe global data. Annotations, pragmas, parallelization libraries, domain-specific languages, and classical full-fledged languages are some of the approaches [20, 21, 22, 23, 24]. Authors [25] have reviewed the literature on General Sparse Matrix-Matrix Multiplication, covering applications, formulations, compression formats, critical issues, strategies, architecture-oriented optimizations, programming models, performance comparisons, algorithm analysis, and areas for further study.

This proposed work is the extended version of our previous work [12]. In our previous work, we evaluated the speed up and efficiency of an algorithm in an OMP environment and found that parallelism can be achieved only after a certain problem size. However, in this proposed work, two effective parallel computing tools (OMP and MATLAB) have been compared and their performances were also evaluated.

3. Implementation of algorithm

A sequential MM algorithm was implemented in OMP and MATLAB and executed in Fedora 17 and Windows operating systems with different processors respectively. The execution time of the sequential run was evaluated first followed by the parallel run. For parallel execution, we have written the parallel code using OMP and MATLAB parallel processing toolbox functionalities and executed it in different processors with dual cores and with two threads only. The sequential (ST) and parallel (PT) running time of the algorithm on different processors was noted down and the performance measures (speed up, efficiency) of the systems were evaluated accordingly.

The algorithm was tested by writing the program in both OMP and MATLAB on a multi-core system and their performances were measured with their execution times as shown in Fig. 1. An analysis and comparison of the outputs from OMP and MATLAB are conducted to determine which, in terms of execution time and performance metrics, performs better. This section outlines every step required to build the method in MATLAB and OMP. Table 1 presents a description of the hardware and software along with the multi-core processors utilized in this investigation.

Table 1
Multi-core processors with specifications

Components	Intel core2duo processor for OMP	Intel Pentium processor for MATLAB
Model	Lenovo 3000 G430	HP Pavilion g4 Notebook PC
Processor cores	Dual-core	Dual-core
Processors used	T5800, Intel^TM Core2Duo CPU, 2.00 GHz	Intel Pentium P6200 CPU operating at 2.13 GHz
RAM	3.00 GB (2.87 GB usable)	4.00 GB (3.80 GB usable)
Operating system	32-bit OS	64-bit OS

Figure 1.

Process flow diagram of steps followed.

In OMP, when we compute execution time without using pragma directive, it is called serial time (ST) and when we make use of pragma command and then time computed is called parallel time (PT). First, the sequential execution time of OMP was recorded and then parallel execution time was calculated by following the aforementioned steps. The ST in MATLAB is that time which is computed without opening the matlabpool. When the matlabpool is open, then it will open 2 threads. Similarly, matlabpool can work up to a maximum of 12 threads. After opening the pool for 2, 4, 8 & 12 threads time taken is called PT.

3.1 Performance measures

The procedure of gathering, evaluating, and reporting data on a system’s performance as well as the technology employed is known as performance measurement. Performance metrics are used to assess a system’s efficacy, efficiency, timeliness, productivity, safety, and quality. Here, the OMP and MATLAB platform’s parallel performance was analyzed using two performance measures such as speed up and efficiency.

3.1.1 Speedup

Speed up is the ratio of the time of execution of a given program using an algorithm on a machine with a single processor (i.e. $T(1)$ , where $n=$ 1) to the time of execution of a similar program using an algorithm on a machine with many processors (i.e. $T(n)$ , where $n=$ 2, 4, …) as shown in Eq. (1). It is a ratio of execution time of changes made before and changes made after the program execution.

$\displaystyle\textit{Speedup}\left({S}\right)=\frac{\textit{Time Taken by}\ 1% \ \textit{Processor}}{\textit{Time Taken by {n} Processor}}=\frac{{T}\left(1% \right)}{{T}\left({n}\right)}$ (1)

It may be noted that the term $T(1)$ specifies the amount of time needed for executing a program using the best sequential algorithm (the algorithm with the least time complexity).

3.1.2 Efficiency

A further crucial indicator for evaluating performance is the efficiency of parallel processors, which explains how the resources are employed. We refer to this as a degree of efficacy. The ratio of the relative speed increase achieved when the load shifts from a single processor machine to a k-processor machine defines the efficiency of a program running on a parallel computing system with k-processors. A parallel computing machine uses a large number of processors to get the desired output.

The efficiency of a program on a $k$ processor, $E(k)$ is defined as the ratio of the speedup achieved and the no processor used to achieve it. The value of $E(k)$ is directly proportional to speed-up and inversely proportional to the number of processors engaged to perform the computation as given in Eq. (2).

$\displaystyle\textit{Efficiency},{E}\left({k}\right)=\frac{\textit{Speedup}}{% \textit{No}.\textit{of processors }\left({k}\right)}$ (2)

4. Results and discussion

In the MM algorithm, no task dependency is observed. Hence thread and kernel instances when run in parallel, reduce the execution time. MM problem was solved using both OMP and MATLAB parallel programming platforms on dual cores for two threads only. It gives the best result by executing it sequentially rather than parallel when several rows and columns are fewer, but as the number of rows and columns increases, the sequential algorithm’s performance decreases where the parallel processing task comes into play.

In the simulation, Fedora 17 with an Intel Core2Duo (2.00 GHz) processor and Windows 7 operating system with an Intel Pentium (2.13 GHz) processor have been used. On both computers, different matrix sizes i.e. from 10 $\times$ 10 to 5000 $\times$ 5000 were multiplied without using OMP, using OMP and MATLAB. Elements of matrices on both computers were generated randomly. To generate numbers randomly rand () function was used and to get computational time omp_get_wtime() function was used in OMP. In MATLAB, the random variable was also defined for generating random numbers. There may be little difference in randomly generated value which can result in little variation in the computation time. However, it is considered to be negligible and neglected in this work. To assess performance, a dataset with sizes ranging from 10 $\times$ 10 to 50 $\times$ 50, 100 $\times$ 100 to 200 $\times$ 200, and up to 5000 $\times$ 5000 was considered. The study found that the OMP sequential execution time for a 10 $\times$ 10 matrix was less than the parallel execution time. However, starting with a 50 $\times$ 50 size matrix, parallel processing produces superior results [12]. with the same result, with MATLAB, sequential execution up to a 300 $\times$ 300 size matrix used less time than parallel processing. However, the performance of the parallel execution improves when the size matrix is larger than 400 $\times$ 400. This indicates that when it comes to parallelism, the problem’s magnitude is also important. The tiny problem size causes a communication bottleneck that in turn causes a parallel slowing phenomenon [14]. In proportion to the number of nodes, communication overhead rises. Occasionally, the duration of communication exceeds that of calculation. This is the reason why parallel processing is slowing down [14]. The matlabpool option increases hard drive space use and slows down the system while using parallel MATLAB. These extra overheads are present in the MATLAB Parallel platform. This implies that parallelism should only be used for problems larger than a specific size. Parallelism is only effective in the present case for OMP and 2.00 GHz CPU after 50 $\times$ 50 MM, whereas it is only effective in the case of MATLAB and 2.13 GHz processor after 400 $\times$ 400 MMs. OMP with a slower processor performs much better than MATLAB with a higher processor. It can be clear from the following observations.

4.1 Comparative analysis of experimental results

Table 2
Sequential time comparison of OMP & MATLAB

Matrix size	OMP ST	MATLAB ST	Time ratio (ST)	OMP PT	MATLAB PT	Time ratio (PT)
10 $\times$ 10	0.000046	0.000042	0.91304	0.000273	0.000042	0.15385
50 $\times$ 50	0.001535	0.003421	2.22866	0.001167	0.003442	2.94944
100 $\times$ 100	0.01327	0.02668	2.01055	0.009603	0.029714	3.09424
200 $\times$ 200	0.029811	0.219269	7.35531	0.021555	0.231863	10.7568
300 $\times$ 300	0.335226	0.76726	2.28878	0.228125	0.778147	3.41106
400 $\times$ 400	1.000831	2.057783	2.05607	0.667475	2.033194	3.0461
500 $\times$ 500	2.127931	4.29322	2.01756	1.421125	4.086374	2.87545
600 $\times$ 600	3.94911	7.745047	1.96121	2.539687	7.74283	3.04873
700 $\times$ 700	6.070147	12.854446	2.11765	3.931948	12.643019	3.21546
800 $\times$ 800	10.625654	20.748464	1.95268	6.459272	20.054002	3.10468
900 $\times$ 900	15.43963	27.427215	1.77642	9.550435	27.190853	2.84708
1000 $\times$ 1000	21.336303	37.741336	1.76888	13.137191	37.132588	2.82652
1500 $\times$ 1500	112.655111	151.43185	1.34421	69.802859	142.26556	2.03811
2000 $\times$ 2000	177.362122	459.43997	2.59041	112.565785	426.246883	3.78665
2500 $\times$ 2500	418.590416	810.13542	1.93539	188.201826	758.304878	4.02921
3000 $\times$ 3000	574.658692	2457.8857	4.27712	298.450969	1499.886812	5.02557
3500 $\times$ 3500	812.505873	4423.3679	5.44411	465.223017	2476.537705	5.32333
4000 $\times$ 4000	1328.852847	8465.3507	6.37042	850.408619	3683.31686	4.33123
4500 $\times$ 4500	1770.902282	2205.453	6.89222	1042.201657	5440.18732	5.2199
5000 $\times$ 5000	2213.815603	9380.749	8.75445	1203.885703	7849.747967	6.52034

Recently few studies have been reported in the direction of comparing OMP and MATLAB. In a poster presentation at UPPSALA University OMP was demonstrated to be 5 times faster than MATLAB [26]. Their work has been done on sparse matrices. But in the proposed study it was found that OMP is more than 8 times faster for sequential execution and 6 times faster for parallel execution than MATLAB. In another recent paper [27], OMP was found to be faster than MATLAB. But in their work ST in MATLAB was always less than the PT. However, in the present work, ST was found to be less than PT beyond a certain matrix size. A larger sample size has also been tested here as compared to this [27] paper.

4.1.1 Comparison of sequential and parallel execution times

Computational execution times of both sequential and parallel runs were recorded in both OMP and MATLAB parallel programming environments. These results are shown in Table 2 and Fig. 2. It was clear from the table and graph that sequential and parallel time taken by MATLAB is more than OMP for the execution of the program. A new performance parameter called time ratio is introduced by us. A time ratio is defined as a ratio between the time required by MATLAB and the time required by OMP (MATLAB/OMP). The time ratio is calculated to find out how much faster is OMP than MATLAB. As far as the sequential time is concerned OMP is 8 times faster than MATLAB. According to the calculated time ratio, the parallel time of OMP is more than 6 times faster as compared to the parallel time of MATLAB.

Figure 2.

ST & PT comparison of OMP & MATLAB.

Thus, from the observation of the above graph, it can be summed up as:

MATLAB ST $>$ MATLAB PT $>$ OMP ST $>$ OMP PT

For OMP:

ST $<$ PT (for below 50 $\times$ 50 matrix size)

ST $>$ PT (from above 50 $\times$ 50 matrix size onwards) [12]

For MATLAB:

ST $<$ PT (for below 400 $\times$ 400 matrix size)

ST $>$ PT (from above 400 $\times$ 400 matrix size onwards)

4.1.2 Comparison of performance metrics

Speed-up and efficiency measures were calculated to evaluate the performance of both OMP and MATLAB programming platforms. These results and graphs were presented in the following sub-sections. The speed up and efficiency between OMP and MATLAB were compared and presented in Table 3, Figs 3, and 4.

Table 3
Comparison between OMP and MATLAB speed up & efficiency

Matrix size	OMP speed up	MATLAB speed up	OMP efficiency	MATLAB efficiency
10 $\times$ 10	0.168498168	1	0.084249084	0.042124542
50 $\times$ 50	1.315338475	0.993898896	0.657669237	0.328834619
100 $\times$ 100	1.381859835	0.897893249	0.690929918	0.345464959
200 $\times$ 200	1.383020181	0.945683442	0.69151009	0.345755045
300 $\times$ 300	1.469483836	0.98600907	0.734741918	0.367370959
400 $\times$ 400	1.499428443	1.01209378	0.749714222	0.374857111
500 $\times$ 500	1.497356672	1.05061847	0.748678336	0.374339168
600 $\times$ 600	1.554959332	1.000286329	0.777479666	0.388739833
700 $\times$ 700	1.543801444	1.016722825	0.771900722	0.385950361
800 $\times$ 800	1.645023464	1.034629597	0.822511732	0.411255866
900 $\times$ 900	1.616641546	1.008692703	0.808320773	0.404160386
1000 $\times$ 1000	1.624114546	1.016393902	0.812057273	0.406028637
1500 $\times$ 1500	1.613903966	1.064430864	0.806951983	0.403475992
2000 $\times$ 2000	1.575630837	1.07787291	0.787815418	0.393907709
2500 $\times$ 2500	2.224157039	1.068350535	1.112078519	0.55603926
3000 $\times$ 3000	1.925471021	1.638714147	0.962735511	0.481367755
3500 $\times$ 3500	1.746486832	1.786109634	0.873243416	0.436621708
4000 $\times$ 4000	1.562605102	2.298295548	0.781302551	0.390651276
4500 $\times$ 4500	1.699193501	2.243572183	0.84959675	0.424798375
5000 $\times$ 5000	1.838891846	2.468964468	0.919445923	0.459722962

Figure 3.

Comparison between OMP and MATLAB speed up.

Figure 4.

Comparison between efficiency of OMP and MATLAB.

4.1.3 Analysis of performance metrics results

The speed-up graph presented in Fig. 3 did not give the correct picture because while calculating the speed-up for MATLAB we took MATLAB sequential time as a numerator. But MATLAB’s sequential time is much larger than the sequential time of OMP. Therefore, the calculated OMP speed-up doesn’t need to be better than the calculated MATLAB speed-up. Therefore, a common base MATLAB sequential time as numerator has been taken and calculated the new speed-up of OMP as shown in Eqs (3) and (4).

$\displaystyle\textit{MATLAB Speed Up}=\frac{\textit{MATLAB Sequential Time}}{{% \textit{MATLAB Parallel Time}}}$ (3) $\displaystyle{\textit{OMP Speed Up New}}=\frac{{\textit{MATLAB Sequential Time% }}}{{\textit{OMP Parallel Time}}}$ (4)

As the speed-up was newly calculated for OMP, so we recalculated the efficiency for it based on the new speed-up as follows in Eqs (5) and (6).

$\displaystyle\textit{MATLAB Efficiency}=\frac{\textit{MATLAB Speed Up}}{% \textit{Number of Processors}}$ (5) $\displaystyle\textit{OMP Efficiency New}=\frac{\textit{OMP Speed Up}_{\textit{% New}}}{\textit{Number of Processors}}$ (6)

4.1.4 Comparison of new speed-up and efficiency results

The calculated new speed-up and efficiency of OMP were compared with MATLAB in Table 4, Figs 5, and 6. It was found that OMP has a better and more consistent speed-up and efficiency than MATLAB.

Table 4
Comparison of new speed up & efficiency

Matrix size	MATLAB speed up	MATLAB efficiency	OMP speed up new	OMP efficiency new
10 $\times$ 10	1	0.04212	0.15385	0.076923077
50 $\times$ 50	0.9938989	0.32883	2.93145	1.465724079
100 $\times$ 100	0.8978932	0.34546	2.7783	1.389149224
200 $\times$ 200	0.9456834	0.34576	10.1725	5.086267687
300 $\times$ 300	0.9860091	0.36737	3.36333	1.681665753
400 $\times$ 400	1.0120938	0.37486	3.08294	1.54146822
500 $\times$ 500	1.0506185	0.37434	3.021	1.510500484
600 $\times$ 600	1.0002863	0.38874	3.04961	1.52480345
700 $\times$ 700	1.0167228	0.38595	3.26923	1.634615463
800 $\times$ 800	1.0346296	0.41126	3.2122	1.606099263
900 $\times$ 900	1.0086927	0.40416	2.87183	1.435914437
1000 $\times$ 1000	1.0163939	0.40603	2.87286	1.436430969
1500 $\times$ 1500	1.0644309	0.40348	2.16942	1.084710964
2000 $\times$ 2000	1.0778729	0.39391	4.08152	2.040762066
2500 $\times$ 2500	1.0683505	0.55604	4.30461	2.152304893
3000 $\times$ 3000	1.6387141	0.48137	8.23548	4.117737907
3500 $\times$ 3500	1.7861096	0.43662	9.50806	4.754029458
4000 $\times$ 4000	2.2982955	0.39065	9.95445	4.977225391
4500 $\times$ 4500	2.2435722	0.4248	11.7112	5.855610025
5000 $\times$ 5000	2.4689645	0.45972	16.0985	8.049247849

In Table 4 it can be seen that OMP Speed Up New is less than 1 for matrix size of 10 $\times$ 10. This is because of the small problem size. After that OMP Speed Up New is always more than 1. It may be noted that the higher the speed up, the better the performance. For performance improvement, speed up should be greater than 1. For a very large size of 5000 $\times$ 5000 MM, it can be observed that OMP Speed Up New is even more than 16 time. This shows that higher is the problem size, better is performance of parallelism. This has been also shown in the paper of Patel et al. [14].

Figure 5.

New speed up comparison between OMP and MATLAB.

Figure 6.

New efficiency comparison between OMP and MATLAB.

It can be clear from Figs 5 and 6 that the speed up and efficiency of OMP is much better as compared to MATLAB parallel environment.

5. Conclusions and future work

It was observed that OMP is more than 8 times faster in sequential and more than 6 times faster in parallel execution as compared to MATLAB parallel environment. We also experimentally found that OMP with an even slower processor performs much better than MATLAB with a higher processor. In the current experiment, OMP is found to be more suitable than Parallel MATLAB due to its faster loading capability and speed of the program. Another reason to consider, OMP is freely available whereas we have to purchase MATLAB. OMP platform is having richness of functions which makes it a viable alternative to MATLAB. Therefore, from our study, it is concluded that for research purposes, the superior tool for parallel computing is OMP rather than parallel MATLAB. This study proposed an innovative and efficient method to find out the applicability of the MM algorithm in OMP and parallel MATLAB. As two different processors were being studied for the dense execution of MM, so the results are worthy enough to substantiate its optimal usability. In the future, we will do a comparative study based on the performance of MM algorithms on other parallel environments like Message Passing Interface (MPI), Compute Unified Device Architecture (CUDA), etc. We will assess the speed and performance of the MM using the higher level of processors i.e., 8 cores and 16 cores. In a given application program, the utility of OMP or Parallel MATLAB in a heterogeneous environment consisting of multiple GPUs and multi-cores can be recognized by using this type of research work.

References

Graham

, “OpenMP: A Parallel Programming Model for Shared Memory Architectures” Edinburgh Parallel Computing Centre, The University of Edinburgh, Version 1.1 March 1999.

Quinn

M.J.

and Hill

, “Parallel Programming in C with MPI and OpenMP” 1st edition, 2004.

Uusheikh, “Begin Parallel Programming with OpenMP” CPOL Malaysia 5 Jun 2007.

OpenMP: https://computing.llnl.gov/tutorials/openMP/.

Parallel computing toolbox, Available online at: www.mathworks.com.

Asanovic

Bodik

Catanzaro

, et al. The landscape of parallel computing research: A view from Berkeley. Technical Report UCB/EECS-2006-183, EECS Department, University of California, Berkeley, December 2006.

Thouti

and Sathe

S.R.

, Comparison of OpenMP and OpenCL Parallel processing Technologies, UACSA 3(4) 2012, 56–61.

Choy

and Edelman

, “Parallel MATLAB: Doing it Right,” Computer Science AI Laboratory, Massachusetts Institute of Technology, Cambridge, MA 02139.

Dadashzadeh

Ternsjö

Engblom

and Lukarski

, “Parallel assembly of sparse matrices using OpenMP,” Department of Information Technology, Box 337, Uppsala Universitet, Sweden.

10.

Hwang

and Jotwani

, “Advanced Computer Architecture”, Tata McGraw Hill Education Private Limited, Second Edition, 2001.

11.

Dash

Kumar

and Patle

V.K.

, “A Survey on Serial and Parallel Optimization Techniques Applicable for Matrix Multiplication Algorithm”, American Journal of Computer Science and Engineering Survey (AJCSES) 3(1), Feb 2015.

12.

Dash

Kumar

and Patle

V.K.

, “Evaluation of Performance on OpenMP Parallel Platform Based on Problem Size,” International Journal of Modern Education and Computer Science (IJMECS) 8(6) (2016), 35–40.

13.

Ali

and Khan

R.Z.

, Performance Analysis of Matrix Multiplication Algorithms Using MPI, International Journal of Computer Science and Information Technologies (IJCSIT) 3(1) (2012), 3103–3106.

14.

Patel

and Kumar

, “Effect of problem size on parallelism”, Proc. of 2nd International Conference on Biomedical Engineering & Assistive Technologies at NIT Jalandhar, (2012), pp. 418–420.

15.

Sharma

S.K.

and Gupta

, “Performance Analysis of Parallel Algorithms on Multi-core System using OpenMP Programming Approaches”, International Journal of Computer Science, Engineering and Information Technology (IJCSEIT) 2(5) (2012).

16.

Kathavate

and Srinath

N.K.

, “Efficiency of Parallel Algorithms on Multi-Core Systems Using OpenMP,” International Journal of Advanced Research in Computer and Communication Engineering 3(10), (October 2014), 8237–8241.

17.

Kulkarni

and Pathare

, “Performance analysis of parallel algorithm over sequential using OpenMP,” IOSR Journal of Computer Engineering (IOSR-JCE) 16(2), 58–62.

18.

Demeure

Kisner

Keskitalo

Thomas

Borrill

and Bhimji

, High-level GPU code: a case study examining JAX and OpenMP. In Proceedings of the SC’23 Workshops of The International Conference on High Performance Computing, Network, Storage, and Analysis, (2023, November), (pp. 1105–1113).

19.

Tabakov

A.V.

and Paznikov

A.A.

, “Algorithms for Optimization of Relaxed Concurrent Priority Queues in Multicore Systems,” 2019 IEEE Conference of Russian Young Researchers in Electrical and Electronic Engineering (EIConRus), Saint Petersburg and Moscow, Russia, 2019, pp. 360–365.

20.

Chen

, Evaluating the Performance of Parallel Computing in Hybrid Models. Available at SSRN 4482277. Andrade, (2023).

21.

Dash

, “An Insight into Parallel Computing Paradigm,” 2019 2nd International Conference on Intelligent Computing, Instrumentation and Control Technologies (ICICICT), Kannur, India, 2019, pp. 804–808.

22.

. (2023). Improving parallel programming assessment: challenges, methods, and opportunities in coding productivity.

23.

2023. GCC Wiki – OpenMP. https://gcc.gnu.org/wiki/openmp. [Online; accessed 30-May-2023].

24.

2023. LLVM/OpenMP Documentation. https://openmp.llvm.org/. [Online; accessed 15-October-2023].

25.

Gao

Chang

Han

Wei

Liu

and Wang

, A Systematic Survey of General Sparse Matrix-matrix Multiplication. ACM Comput. Surv. 55, 12, Article 244 (March 2023), 3.

26.

Dadashzadeh

Ternsjö

Engblom

and Lukarski

, “Parallel assembly of sparse matrices using OpenMP,” Department of Information Technology, Box 337, Uppsala Universitet, Sweden.

27.

Rathod

A.B.

Gulhane

S.M.

Faye

V.L.

and Fulkar

K.A.

, “A Comparative Evaluation of Parallel Matlab and OpenMP Parallel Technologies,” IETE 46th Midterm Symposium “Impact of Technology on Skill Development, MTS-2015” Special Issue of International Journal of Electronics, Communication & Soft Computing Science and Engineering 4(2) (2015), 199–202.

A comparative assessment of OMP and MATLAB for parallel computation

Abstract

Keywords

1. Introduction

2. Related work

3. Implementation of algorithm

Table 1 Multi-core processors with specifications

3.1.1 Speedup

4.1 Comparative analysis of experimental results

Table 2 Sequential time comparison of OMP & MATLAB

Table 3 Comparison between OMP and MATLAB speed up & efficiency

Table 4 Comparison of new speed up & efficiency

References

Table 1
Multi-core processors with specifications

Table 2
Sequential time comparison of OMP & MATLAB

Table 3
Comparison between OMP and MATLAB speed up & efficiency

Table 4
Comparison of new speed up & efficiency