The impact of scheduling gangs with the shortest execution time on gang scheduling performance

In this paper, the authors highlight the existence of close relations between the execution time, efficiency and number of communication rounds in a family of CGM-based parallel algorithms for the optimal binary search tree problem (OBST). In this case, these three parameters cannot be simultaneously improved. The family of CGM (Coarse Grained Multicomputer) algorithms they derive is based on Knuth's sequential solution running in time and space, where n is the size of the problem. These CGM algorithms use p processors, each with local memory. In general, the authors show that each algorithms runs in with communications rounds. is the granularity of their model, and is a parameter that depends on and . The special case of yields a load-balanced CGM-based parallel algorithm with communication rounds and execution steps. Alternately, if , they obtain another algorithm with better execution time, say , the absence of any load-balancing and communication rounds, i.e., not better than the first algorithm. The authors show that the granularity has a crucial role in the different techniques they use to partition the problem to solve and study the impact of each scheduling algorithm. To the best of their knowledge, this is the first unified method to derive a set of parameter-dependent CGM-based parallel algorithms for the OBST problem.

Download Full-text

Performance Evaluation of a Big Data Application on Apache Spark

10.32920/ryerson.14651544 ◽

2021 ◽

Author(s):

Jeanne Alcantara

Keyword(s):

Big Data ◽

Performance Evaluation ◽

Execution Time ◽

Apache Spark ◽

Massive Data ◽

Application Performance ◽

Data Application ◽

Size Number ◽

Big Data Application ◽

The Impact

Apache Spark enables a big data application—one that takes massive data as input and may produce massive data along its execution—to run in parallel on multiple nodes. Hence, for a big data application, performance is a vital issue. This project analyzes a WordCount application using Apache Spark, where the impact on the execution time and average utilization is assessed. To facilitate this assessment, the number of executor cores and the size of executor memory are varied across different sizes of data that the application has to process, and the different number of nodes in the cluster that the application runs on. It is concluded that different pairs (data size, number of nodes in the cluster) require different number of executor cores and different size of executor memory to obtain optimum results for execution time and average node utilization.

Download Full-text

Performance Evaluation of a Big Data Application on Apache Spark

10.32920/ryerson.14651544.v1 ◽

2021 ◽

Author(s):

Jeanne Alcantara

Keyword(s):

Big Data ◽

Performance Evaluation ◽

Execution Time ◽

Apache Spark ◽

Massive Data ◽

Application Performance ◽

Data Application ◽

Size Number ◽

Big Data Application ◽

The Impact

Apache Spark enables a big data application—one that takes massive data as input and may produce massive data along its execution—to run in parallel on multiple nodes. Hence, for a big data application, performance is a vital issue. This project analyzes a WordCount application using Apache Spark, where the impact on the execution time and average utilization is assessed. To facilitate this assessment, the number of executor cores and the size of executor memory are varied across different sizes of data that the application has to process, and the different number of nodes in the cluster that the application runs on. It is concluded that different pairs (data size, number of nodes in the cluster) require different number of executor cores and different size of executor memory to obtain optimum results for execution time and average node utilization.

Download Full-text

Investigating Parallel Programming Paradigms in HeMPS MPSoC Platform

10.5753/wscad.2019.8665 ◽

2019 ◽

Author(s):

Geaninne Lopes ◽

Aline Mello ◽

Ewerson Carvalho ◽

César Marcon

Keyword(s):

Parallel Programming ◽

Power Dissipation ◽

Execution Time ◽

Matrix Multiplication ◽

Divide And Conquer ◽

Image Manipulation ◽

Multiprocessor System ◽

Input Size ◽

Programming Paradigms ◽

The Impact

This work investigates the use of parallel programming paradigms in the development of applications targeting a Multiprocessor System-on-Chip (MPSoC). We implemented Matrix Multiplication, Image Manipulation and Advanced Encryption Standard (AES) applications in the Master-Slave, Pipeline and Divide-and-Conquer paradigms, and applied execution time and power dissipation as criteria for evaluating the performance of the applications executing according to the paradigms on an MPSoC architecture. The obtained results allowed us to conclude that there are optimal application-paradigm relations. Pipeline presents lower execution time and lower power dissipation for the Image Manipulation application; whereas, Master-Slave performs better for the Matrix Multiplication and AES applications. However, when the input size of the applications increases, the Divide-and-Conquer paradigm tends to minimize the execution time for Matrix Multiplication application. The main contributions of this work are the development of applications, considering different paradigms, and the impact evaluation of these paradigms on MPSoC architecture.

Download Full-text

Emotion Recognition using a Multi-view learning method

Zambia ICT Journal ◽

10.33260/zictjournal.v4i1.99 ◽

2020 ◽

Vol 4 (1) ◽

pp. 1-5

Author(s):

Michele Mukeshimana ◽

Jeremie Ndikumagenge ◽

BiHilaire Nkunzimana ◽

Abraham Niyongere ◽

ComXiaojuan Ban

Keyword(s):

Emotion Recognition ◽

Execution Time ◽

Recognition Accuracy ◽

Daily Life ◽

Combination Method ◽

Fusion Method ◽

Learning Method ◽

Accuracy Improvement ◽

Multiple Features ◽

The Impact

The increasing use of computing devices and applications in human daily life triggers the need for natural human-computer interaction. Emotion Recognition using multiple features using a semi-serial fusion method is proposed. The study analyses the impact of the feature combinations in the enhancement of the recognition enhancement. The paper presents the use of the multi-view learning principle to a fusion of different features for one emotion expression-based recognition. The results prove that a planned method is operative. The proposed combination method outperforms the use of one type of features and the concatenated way in recognition accuracy, improvement of execution time, and stability.

Download Full-text

Studies of GEANT4 performance for different ATLAS detector geometries and code compilation methods

EPJ Web of Conferences ◽

10.1051/epjconf/202125103005 ◽

2021 ◽

Vol 251 ◽

pp. 03005

Author(s):

Caterina Marcon ◽

Einar Elén ◽

Jessica Rebecca Madeira ◽

Benjamin Morgan ◽

Oxana Smirnova ◽

...

Keyword(s):

Execution Time ◽

Atlas Detector ◽

Geant4 Simulation ◽

Viable Option ◽

Factors Affecting ◽

Primary Particles ◽

Dynamic Library ◽

Detector Simulation ◽

The Impact

Full detector simulation is known to consume a large proportion of computing resources available to the LHC experiments, and reducing time consumed by simulation will allow for more profound physics studies. There are many avenues to exploit, and in this work we investigate those that do not require changes in the GEANT4 simulation suite. In this study, several factors affecting the full GEANT4 simulation execution time are investigated. A broad range of configurations has been tested to ensure consistency of physical results. The effect of a single dynamic library GEANT4 build type has been investigated and the impact of different primary particles at different energies has been evaluated using GDML and GeoModel geometries. Some configurations have an impact on the physics results and are, therefore, excluded from further analysis. Usage of the single dynamic library is shown to increase execution time and does not represent a viable option for optimization. Lastly, the static build type is confirmed as the most effective method to reduce the simulation execution time.

Download Full-text

Path Mapping Approach for Network Function Virtualization Resource Allocation with Network Function Decomposition Support

Symmetry ◽

10.3390/sym11091173 ◽

2019 ◽

Vol 11 (9) ◽

pp. 1173 ◽

Cited By ~ 1

Author(s):

Basheer Raddwan ◽

Khalil AL-Wagih ◽

Ibrahim A. Al-Baltah ◽

Mohamed A. Alrshah ◽

Mohammed A. Al-Maqri

Keyword(s):

Resource Allocation ◽

Execution Time ◽

Service Providers ◽

Virtual Network ◽

Network Function Virtualization ◽

Network Function ◽

Function Decomposition ◽

Mapping Approach ◽

Network Functions ◽

The Impact

Recently, Network Function Virtualization (NFV) and Software Defined Networking (SDN) have attracted many mobile operators. For the flexible deployment of Network Functions (NFs) in an NFV environment, NF decompositions and control/user plane separation have been introduced in the literature. That is to map traditional functions into their corresponding Virtual Network Functions (VNFs). This mapping requires the NFV Resource Allocation (NFV-RA) for multi-path service graphs with a high number of virtual nodes and links, which is a complex NP-hard problem that inherited its complexity from the Virtual Network Embedding (VNE). This paper proposes a new path mapping approach to solving the NFV-RA problem for decomposed Network Service Chains (NSCs). The proposed solution has symmetrically considered optimizing an average embedding cost with an enhancement on average execution time. The proposed approach has been compared to two other existing schemes using 6 and 16 scenarios of short and long simulation runs, respectively. The impact of the number of nodes, links and paths of the service requests on the proposed scheme has been studied by solving more than 122,000 service requests. The proposed Integer Linear Programming (ILP) and heuristic schemes have reduced the execution time up to 39.58% and 6.42% compared to existing ILP and heuristic schemes, respectively. Moreover, the proposed schemes have also reduced the average embedding cost and increased the profit for the service providers.

Download Full-text

Towards An Implementation of A Modified Static Load Balancing Algorithm To Minimize Execution Time

Recent Patents on Computer Science ◽

10.2174/2213275911666181022113733 ◽

2019 ◽

Vol 12 (1) ◽

pp. 69-74

Author(s):

Hioual Ouided ◽

Laskri Mhamed Tayeb ◽

Hemam Sofiane Mounine ◽

Hioual Ouassila ◽

Maifi Lyes

Keyword(s):

Load Balancing ◽

Failure Probability ◽

Execution Time ◽

Static Load ◽

Optimal Algorithm ◽

Scheduling Algorithm ◽

Static Load Balancing ◽

Load Balancing Algorithm ◽

Two Parameters ◽

The Impact

Purpose: The aim of this article is to discuss the impact of static load balancing over a set of heterogeneous processors, where tasks are independent and unitary in static environments, by showing how to distribute task in order to optimize both the average response time and the degree of the resources used. Methods: Implementation of a modified scheduling algorithm, the latter is based on two parameters which are the execution time and the failure probability. The algorithm is based on the results of an optimal algorithm that already exists, with only one parameter that is execution time. Results: The obtained results show that the modified scheduling algorithm gives us the good results. Conclusion: The modified algorithm assumes that the processor has smallest execute time. So, the failure probability increases because of it’s frequently use. The results obtained by testing this proposed algorithm are better than the optimal algorithm.

Download Full-text

How Software Refactoring Impacts Execution Time

ACM Transactions on Software Engineering and Methodology ◽

10.1145/3485136 ◽

2022 ◽

Vol 31 (2) ◽

pp. 1-23

Author(s):

Luca Traini ◽

Daniele Di Pompeo ◽

Michele Tucci ◽

Bin Lin ◽

Simone Scalabrino ◽

...

Keyword(s):

Execution Time ◽

Careful Consideration ◽

Software Performance ◽

Functional Requirements ◽

Software Developers ◽

Software Refactoring ◽

Performance Benchmarks ◽

History Of ◽

External Behavior ◽

The Impact

Refactoring aims at improving the maintainability of source code without modifying its external behavior. Previous works proposed approaches to recommend refactoring solutions to software developers. The generation of the recommended solutions is guided by metrics acting as proxy for maintainability (e.g., number of code smells removed by the recommended solution). These approaches ignore the impact of the recommended refactorings on other non-functional requirements, such as performance, energy consumption, and so forth. Little is known about the impact of refactoring operations on non-functional requirements other than maintainability. We aim to fill this gap by presenting the largest study to date to investigate the impact of refactoring on software performance, in terms of execution time. We mined the change history of 20 systems that defined performance benchmarks in their repositories, with the goal of identifying commits in which developers implemented refactoring operations impacting code components that are exercised by the performance benchmarks. Through a quantitative and qualitative analysis, we show that refactoring operations can significantly impact the execution time. Indeed, none of the investigated refactoring types can be considered “safe” in ensuring no performance regression. Refactoring types aimed at decomposing complex code entities (e.g., Extract Class/Interface, Extract Method) have higher chances of triggering performance degradation, suggesting their careful consideration when refactoring performance-critical code.

Download Full-text